source: proiecte/ptvs/src/vnsim/vehicular/simulator/RouteSegment.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;



import java.util.*;

import vnsim.map.object.*;


public class RouteSegment implements java.io.Serializable {

        //a segment, identified by a road index and two point indexes
        //(the order of the point indexes does matter - there are two possible ways
        //to look at the same segment, depending on the direction)
        
        /** <code>serialVersionUID</code> */
        private static final long serialVersionUID = -5883719321862303634L;

        public short roadIndex;
        public short pt1;
        public short pt2;

        //pt1 and pt2 are point indexes on the road 'roadIndex'; they can be in any order
        //(pt1>pt2 or pt1<pt2)

        public RouteSegment(short roadIndex, short pt1, short pt2) {
                this.roadIndex=roadIndex;
                this.pt1=pt1;
                this.pt2=pt2;
        }

        public boolean contains(Location loc) {
                if(pt1>=pt2) {
                        for(int i=pt2;i<=pt1;i++) {
                                Location test=new Location(roadIndex,i);
                                if(test.equals(loc))
                                        return true;
                        }
                } else {
                        for(int i=pt1;i<=pt2;i++) {
                                Location test=new Location(roadIndex,i);
                                if(test.equals(loc))
                                        return true;
                        }
                }
                return false;
        }

        public boolean checkOrder(Location l1, Location l2) {
                //checks whether l1 and l2 appear in the current route segment, in this order
                int state=0; //0=none found; 1=l1 found

                if(l1.roadIdx==l2.roadIdx && l1.roadIdx==this.roadIndex) {
                        if(pt1>=pt2) {
                                if(pt1>=l1.ptIdx && l1.ptIdx>=l2.ptIdx && l2.ptIdx>=pt2)
                                        return true;
                                return false;
                        } else {
                                if(pt1<=l1.ptIdx && l1.ptIdx<=l2.ptIdx && l2.ptIdx<=pt2)
                                        return true;
                                return false;
                        }
                }
                if(l1.equals(l2)) return this.contains(l1);

//              else check each point
                if(pt1>=pt2) {
                        for(int i=pt1;i>=pt2;i--) {
                                Location test=new Location(roadIndex,i);
                                if(state==0) {
                                        if(test.equals(l2)) return false;
                                        if(test.equals(l1)) state=1;
                                } else {
                                        if(test.equals(l2)) return true;
                                }
                        }
                } else {
                        for(int i=pt1;i<=pt2;i++) {
                                Location test=new Location(roadIndex,i);
                                if(state==0) {
                                        if(test.equals(l2)) return false;
                                        if(test.equals(l1)) state=1;
                                } else {
                                        if(test.equals(l2)) return true;
                                }
                        }
                }
                return false;
        }

        public double distanceBetween(Location loc) {
                //assume loc is inside the current route segment; get the distance from loc
                //to the end of the current route segment;
                //return -1.0 on error;
                
                Road r=(Road) Globals.map.roads.get(roadIndex);
                if(loc.roadIdx==this.roadIndex) {
                        if(pt1>=pt2) {
                                return ((r.points.get(loc.ptIdx))).getDistance()
                                -
                                ((r.points.get(pt2))).getDistance();
                        } else {
                                return ((Point)(r.points.get(pt2))).getDistance()
                                -
                                ((Point)(r.points.get(loc.ptIdx))).getDistance();
                        }
                }

                //else check each point
                if(pt1>=pt2) {
                        for(int i=pt2;i<=pt1;i++) {
                                Location test=new Location(roadIndex,i);
                                if(test.equals(loc)) {
                                        return ((Point)(r.points.get(i))).getDistance()
                                                -
                                                ((Point)(r.points.get(pt2))).getDistance();
                                }
                        }
                } else {
                        for(int i=pt1;i<=pt2;i++) {
                                Location test=new Location(roadIndex,i);
                                if(test.equals(loc)) {
                                        return ((Point)(r.points.get(pt2))).getDistance()
                                                -
                                                ((Point)(r.points.get(i))).getDistance();
                                }
                        }
                }
                return -1.0;
        }

        public double distanceFrom(Location loc) {
                //assume loc is inside the current segment!
                //calculates the distance between the start of the current route segment and the location loc;
                //return -1.0 on error;
                Road r=(Road) Globals.map.roads.get(roadIndex);
                if(loc.roadIdx==this.roadIndex) {
                        if(pt1>=pt2) {
                                return ((r.points.get(pt1))).getDistance()
                                -
                                ((r.points.get(loc.ptIdx))).getDistance();
                        } else {
                                return ((r.points.get(loc.ptIdx))).getDistance()
                                -
                                ((r.points.get(pt1))).getDistance();
                        }
                }

                //else check each point
                if(pt1>=pt2) {
                        for(int i=pt2;i<=pt1;i++) {
                                Location test=new Location(roadIndex,i);
                                if(test.equals(loc)) {
                                        return ((Point)(r.points.get(pt1))).getDistance()
                                                -
                                                ((Point)(r.points.get(i))).getDistance();
                                }
                        }
                } else {
                        for(int i=pt1;i<=pt2;i++) {
                                Location test=new Location(roadIndex,i);
                                if(test.equals(loc)) {
                                        return ((Point)(r.points.get(i))).getDistance()
                                                -
                                                ((Point)(r.points.get(pt1))).getDistance();
                                }
                        }
                }
                return -1.0;
        }

        public boolean equals(RouteSegment other) {
                if(this.roadIndex==other.roadIndex) {
                        if(this.pt1==other.pt1 && this.pt2==other.pt2)
                                return true;
                        if(this.pt2==other.pt1 && this.pt1==other.pt2)
                                return true;
                        return false;
                }
                return false;
        }
        
        public String toString() {
                String ret="";
                //ret=ret+"[Rd "+rdIdx1+" Pt "+ptIdx1+"--Rd "+rdIdx2+" Pt "+ptIdx2;
                try{
                        ret=ret+"[Rd:"+roadIndex+";From="+pt1+";To="+pt2+"]";
                        return ret;
                } catch (Exception ex) {
                        ret="EXCEPTION! RouteSegment.toString()!";
                        return ret;
                }
        }
}