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

Last change on this file since 31 was 31, checked in by (none), 14 years ago
File size: 5.8 KB
Line 
1/************************************************************************************
2 * Copyright (C) 2008 by Politehnica University of Bucharest and Rutgers University
3 * All rights reserved.
4 * Refer to LICENSE for terms and conditions of use.
5 ***********************************************************************************/
6package vnsim.vehicular.simulator.intersections;
7
8
9import java.util.ArrayList;
10
11//import vnsim.core.CarInfo;
12import vnsim.map.object.*;
13import vnsim.vehicular.simulator.*;
14
15
16
17
18
19public abstract class Intersection implements java.io.Serializable {
20       
21        /** <code>serialVersionUID</code> */
22        private static final long serialVersionUID = -5883719321862303634L;
23       
24        public ArrayList<DirectedRoadSegment> segments; //ordered by priority (first 2 have priority)
25
26        public abstract void addCrossingSegment(DirectedRoadSegment drs);
27
28        //seg1=segment on which a vehicle is
29        //seg2=segment on which a vehicle intends to go
30
31        public abstract boolean mustStop(RouteSegment seg1, RouteSegment seg2);
32        public abstract boolean havePriority(RouteSegment seg1, RouteSegment seg2);
33        public abstract double getMaximumSpeed(RouteSegment seg1, RouteSegment seg2);
34        public abstract double getInfluenceDistance(RouteSegment seg1, RouteSegment seg2);
35        public abstract double getInfluenceDistanceLaneChange(RouteSegment seg1, RouteSegment seg2);
36       
37        public abstract ArrayList<DirectedRoadSegment> yieldFor(RouteSegment seg1,
38                        RouteSegment seg2);
39       
40        public abstract boolean hasTrafficLights();
41       
42        protected boolean isOrder(int i, int j, int k) {
43                //i,j,k = indices in "segments"
44                //return true if segments i,j,k are in this order, in a sorting by the angle,
45                //counter-clock-wise
46                if (i>=segments.size()||j>=segments.size()||k>=segments.size()){
47                        return false;
48                }
49                double angle1=segments.get(i).angle;
50                double angle2=segments.get(j).angle;
51                double angle3=segments.get(k).angle;
52                if(angle1<angle2) {
53                        if(angle3>angle2 || angle3<angle1)
54                                return true;
55                        else
56                                return false;
57                } else {
58                        if(angle3>angle2 && angle3<angle1)
59                                return true;
60                        else 
61                                return false;
62                }
63        }
64
65        public ArrayList<Byte> getDesiredLanes(RouteSegment src, RouteSegment dst) {
66
67                //should return a sorted vector!
68                int i=-1, j=-1;
69                ArrayList<Byte> ret=new ArrayList<Byte> ();
70                for(i=0;i<segments.size();i++) {
71                        if(segments.get(i).isSameSegment(src))
72                                break;
73                }
74                for(j=0;j<segments.size();j++) {
75                        if(segments.get(j).isSameSegment(dst))
76                                break;
77                }
78                if(i==segments.size() || j==segments.size()) {
79                        System.out.println("ERROR! getDesireLanes! RouteSegment not found in intersection!");
80                       
81                        System.out.println("SRC="+src+";DST="+dst+";INTERSECTION="+this.segments);
82                        ret.add((byte)1);
83                        return ret;
84                }
85                if(segments.size()>3) {
86                        //at least 4 segments
87                       
88                        //is there another road between src and dst (counter-clockwise) ?
89                        boolean isThere1=false;
90                        for(int k=0;k<segments.size();k++) {
91                                if(k==i || k==j)
92                                        continue;
93                                if(isOrder(i,k,j))
94                                        isThere1=true;
95                        }
96
97                        //is there another road between src and dst (clockwise) ?
98                        boolean isThere2=false;
99                        for(int k=0;k<segments.size();k++) {
100                                if(k==i || k==j)
101                                        continue;
102                                if(isOrder(i,j,k))
103                                        isThere2=true;
104                        }
105                        if(isThere1 && isThere2) {
106                                //any lane
107                                for(int l=1;l<=Globals.map.roads.get(src.roadIndex).laneNo;l++) {
108                                        ret.add((byte)l);
109                                }
110                                return ret;
111                        }
112                        if(isThere1) {
113                                //leftmost lane
114                                ret.add((byte)Globals.map.roads.get(src.roadIndex).laneNo);
115                                return ret;
116                        }
117                        if(isThere2) {
118                                //rightmost lane
119                                ret.add((byte)1);
120                                return ret;
121                        }
122                        System.out.println("ERROR! getDesiredLanes - should not get here!");
123                        ret.add((byte)1);
124                        return ret;
125                }
126               
127                if(segments.size()==3) {
128                        //priority road = any lane
129                        if((i==0 && j==1) || (i==1 && j==0)) {
130                                for(int l=1;l<=Globals.map.roads.get(src.roadIndex).laneNo;l++) {
131                                        ret.add((byte)l);
132                                }
133                                return ret;
134                        }
135                       
136                        //is there another road between src and dst (counter-clockwise) ?
137                        boolean isThere1=false;
138                        for(int k=0;k<segments.size();k++) {
139                                if(k==i || k==j)
140                                        continue;
141                                if(isOrder(i,k,j))
142                                        isThere1=true;
143                        }
144                        if(isThere1) {
145                                //leftmost lane
146                                ret.add((byte)Globals.map.roads.get(src.roadIndex).laneNo);
147                                return ret;
148                        }
149                        //rightmost lane
150                        ret.add((byte)1);
151                        return ret;
152                }
153               
154                //any lane
155                for(int l=1;l<=Globals.map.roads.get(src.roadIndex).laneNo;l++) {
156                        ret.add((byte)l);
157                }
158                return ret;
159        }
160
161        public Point getMapPoint(){
162                if (segments.size() == 0)
163                        return null;
164                Road r = Globals.map.roads.get(segments.get(0).roadIndex);
165                Point p = r.points.get(segments.get(0).pointIndex);
166                return p;
167        }
168
169        public boolean equals(Object arg0) {
170                Intersection x = (Intersection)arg0;
171               
172                if (x.segments.size() != segments.size())
173                        return false;
174                for (int i = 0; i < segments.size(); i++){
175                        if (!segments.get(i).equals(x.segments.get(i))){
176                                return false;
177                        }
178                }
179                return true;
180        }
181       
182        public boolean isScissors(RouteSegment src1, RouteSegment dst1, RouteSegment src2, RouteSegment dst2) {
183                int i=-1, j=-1,k=-1, l=-1;
184               
185                for(i=0;i<segments.size();i++) {
186                        if(segments.get(i).isSameSegment(src1))
187                                break;
188                }
189                for(j=0;j<segments.size();j++) {
190                        if(segments.get(j).isSameSegment(dst1))
191                                break;
192                }
193                for(k=0;k<segments.size();k++) {
194                        if(segments.get(k).isSameSegment(src2))
195                                break;
196                }
197                for(l=0;l<segments.size();l++) {
198                        if(segments.get(l).isSameSegment(dst2))
199                                break;
200                }
201               
202                if(i==-1 || j==-1 || k==-1 || l==-1)
203                        return false;
204               
205                if(isOrder(l, k, j) && isOrder(k, j, i) && isOrder(j, i, l)) {
206//                      System.out.println("T");
207                        return true;
208                }
209               
210                if(isOrder(i,l,k) && isOrder(l,k,j) && isOrder(k,j,i)) {
211//                      System.out.println("T");
212                        return true;
213                }
214               
215                return false;
216        }
217
218}
Note: See TracBrowser for help on using the repository browser.