source: proiecte/ptvs/src/vnsim/socialNet/Main.java @ 31

package vnsim.socialNet;


import vnsim.socialNet.GlobalNetwork;
import vnsim.gui.MapLoader;
import vnsim.map.object.*;

import java.util.ArrayList;

import java.io.File;

import javax.swing.JFileChooser;
import javax.swing.JOptionPane;

import vnsim.vehicular.generator.NewCarEvent;
import vnsim.vehicular.routePlan.RouteComputingUtils;
import vnsim.vehicular.scenarios.EntryExitScenario;
import vnsim.vehicular.scenarios.EntryScenario;
import vnsim.vehicular.scenarios.Route;
import vnsim.vehicular.simulator.Location;
import vnsim.vehicular.simulator.RouteSegment;
import vnsim.vehicular.scenarios.Scenario;

public class Main {
        
        public static Scenario getScenario(String map, ArrayList<Location> entries, ArrayList<Location> exits,ArrayList<String> driverTypes, ArrayList<Route> routes, String name){
                Scenario s = new Scenario(map,entries,exits,driverTypes,routes,name);

                EntryScenario es;
                EntryExitScenario ees;
                int i, j;
                Route r;
                
                for (i = 0; i < entries.size(); i++) {
                        es = new EntryScenario(entries.get(i));
                        es.flow = 400;
                        es.percentsDriverTypes.add(new Integer(GlobalNetwork.CALM));
                        es.percentsDriverTypes.add(new Integer(GlobalNetwork.REGULAR));
                        es.percentsDriverTypes.add(new Integer(GlobalNetwork.AGGRESIVE));

                        ees = new EntryExitScenario(entries.get(i), exits.get(i));
                        ees.percentsEachRoute.add(new Integer(100));
                        r = new Route();
                        r.entry = entries.get(i);
                        r.exit = exits.get(i);
                        r.route = new ArrayList<RouteSegment>();
                        try {
                                r = returnRoute(r.entry, r.exit);

                        } catch (Exception e) {
                        }
                        
                        ees.routes.add(r);
                        es.entryExits.add(ees);
                        s.allRoutes.add(r);

                        for (j = 0; j < es.entryExits.size(); j++) {
                                es.entryExits.get(j).percentOfFlow = (int) (100);
                        }
                        s.entryScenarios.add(es);
                }
                return s;
        }
        
        public static Route returnRoute(Location entrie, Location exit){
                RouteComputingUtils rcu = new RouteComputingUtils();
                //return rcu.bestRoute(entrie,exit);
                return rcu.shortestPathByTimeAproximation(entrie,exit);
        }
        
        public static ArrayList<Route> returnRoutes(ArrayList<Location> entries, ArrayList<Location> exits){
                ArrayList<Route> route = new ArrayList<Route>();
                for(int i=0;i<entries.size();i++){
                        Route raux = returnRoute(entries.get(i),exits.get(i));
                        route.add(raux);
                }
                return route;
        }
        
        public static Route returnSocialNetworkRoute(int i,Location entry, Location exit, Mobility mob, int cellX[], int cellY[]){
                ArrayList<RouteSegment> rs = mob.getSocialAtractionRoute(i,cellX, cellY);
                Route route = new Route();
                route.entry = entry;
                route.exit = exit;
                route.route = rs;
                return route;
        }
        
        public static ArrayList<Route> returnSocialNetworkRoutes(ArrayList<Location> entries, ArrayList<Location> exits,Mobility mob, int cellX[], int cellY[]){
                ArrayList<Route> route = new ArrayList<Route>();
                for(int i=0;i<entries.size();i++){
                        Route raux = returnSocialNetworkRoute(i,entries.get(i),exits.get(i),mob,cellX,cellY);
                        route.add(raux);
                }
                return route;
        }
        
        public static Scenario recofigurare(){
                
                Mobility mob = GlobalNetwork.socialMobility;
                ArrayList<Location> entries; 
                ArrayList<Location> exits;
                mob.deleteAll();
                mob.reconfigureEntrie();
                mob.placeNodes(0);
                mob.initalPositions();
                entries = mob.getLocations();
                int cellX[] = new int[GlobalNetwork.nrHosts];
                int cellY[] = new int[GlobalNetwork.nrHosts];
                mob.getPositions(cellX,cellY);
                mob.deleteAll();
                mob.reconfigureExit();
                mob.placeNodes(1);
                mob.initalPositions();
                exits = mob.getLocations();
                ArrayList<Route> route;
                Scenario s;
                if(GlobalNetwork.numberOfReconfigurations%2==0){
                        route = returnRoutes(exits,entries);
                        s = getScenario(GlobalNetwork.mapName,exits,entries,GlobalNetwork.driverType,route,GlobalNetwork.name);
                        GlobalNetwork.entries = exits;
                        GlobalNetwork.exits = entries;
                }
                else{
                        if(GlobalNetwork.routingType==0){
                                route = returnSocialNetworkRoutes(entries,exits,mob,cellX,cellY);
                        }
                        else{
                                route = returnRoutes(entries,exits);
                        }
                        //route = returnRoutes(entries,exits);
                        s = getScenario(GlobalNetwork.mapName,entries,exits,GlobalNetwork.driverType,route,GlobalNetwork.name);
                        GlobalNetwork.entries = entries;
                        GlobalNetwork.exits = exits;
                }
                
                GlobalNetwork.numberOfReconfigurations=GlobalNetwork.numberOfReconfigurations+1;
                GlobalNetwork.nextReconfigurationTime=(GlobalNetwork.numberOfReconfigurations+1)*GlobalNetwork.CONFTIME;
                
                GlobalNetwork.socialMobility = mob;
                
                return s;
        }
        
        public static void addCarEvents(Scenario sc, int crtTime){
                ArrayList<EntryScenario> entryScenarios=sc.entryScenarios;

                for(int i=0;i<entryScenarios.size();i++) {
                        EntryScenario es=entryScenarios.get(i);
                        vnsim.vehicular.generator.Mobility.entryScenarios.add(es);
                        int period=(int)((double)3600*Globals.executionFPS / (double)es.flow);
                        NewCarEvent nce=new NewCarEvent(crtTime+period,i, period);
                        vnsim.vehicular.generator.Mobility.events.addEvent(nce);
                }
        }
        
        public static void main(String args[]) throws Exception{
                System.out.println("In main - "+args[0]+" - "+GlobalNetwork.CALM+" "+GlobalNetwork.AGGRESIVE+" "+GlobalNetwork.REGULAR);
                System.out.println(GlobalNetwork.THESHOLD+" "+GlobalNetwork.REWIRE);
                System.out.println(GlobalNetwork.CONFTIME);
                System.out.println(GlobalNetwork.ROWS+" "+GlobalNetwork.COLUMNS+" "+GlobalNetwork.GROUPS);
                System.out.println("priority: "+GlobalNetwork.PRIORITY+" "+GlobalNetwork.priorityType);
                
                Globals.SOCIALNETWORK = 1;
                
//              MapLoader.loadSimulationParameters();
                
                Util.getCellSize(args[0]);      
                
                System.out.println("Map loaded...");
                
                GlobalNetwork.numberOfReconfigurations=0;
                GlobalNetwork.nextReconfigurationTime=GlobalNetwork.CONFTIME; 
                GlobalNetwork.nrHosts = GlobalNetwork.AGGRESIVE + GlobalNetwork.CALM + GlobalNetwork.REGULAR;
                
                GlobalNetwork.LENGTHX = GlobalNetwork.pointMax.getLongitude() - GlobalNetwork.pointMin.getLongitude();
                GlobalNetwork.LENGTHY = GlobalNetwork.pointMax.getLatitude() - GlobalNetwork.pointMin.getLatitude();
                
                if(GlobalNetwork.GROUPS > GlobalNetwork.nrHosts){
                        GlobalNetwork.GROUPS = GlobalNetwork.nrHosts;
                }
                
                vnsim.socialNet.Mobility mob = new vnsim.socialNet.Mobility();
                
                if(GlobalNetwork.priorityType==0){
                        mob.setPriorityEntry();
                        mob.setPriorityExit();
                }
                if(GlobalNetwork.priorityType==1){
                        mob.setPriorityEntryCenter(false);
                        mob.setPriorityExitCenter(true);
                }
                if(GlobalNetwork.priorityType==2){
                        mob.setPriorityEntryCenter(false);
                        mob.setPriorityExitCenter(false);
                }
                
                mob.reconfigureEntrie();
                
                mob.placeNodes(0);
                
                mob.initalPositions();
                
                ArrayList<Location> entries = mob.getLocations();
                
                int cellX[] = new int[GlobalNetwork.nrHosts];
                int cellY[] = new int[GlobalNetwork.nrHosts];
                mob.getPositions(cellX,cellY);
                
                mob.deleteAll();
                
                mob.reconfigureExit();
                
                mob.placeNodes(1);
                
                mob.initalPositions();
                
                ArrayList<Location> exits = mob.getLocations();
                
                ArrayList<Route> route;
                if(GlobalNetwork.routingType==0){
                        route = returnSocialNetworkRoutes(entries,exits,mob,cellX,cellY);
                }
                else{
                        route = returnRoutes(entries,exits);
                }
                //ArrayList<Route> route = returnRoutes(entries,exits);
                //ArrayList<Route> route = returnSocialNetworkRoutes(entries,exits,mob,cellX,cellY);
                
                ArrayList<String> driverTypes = new ArrayList<String>();
                driverTypes.add("very calm");
                driverTypes.add("regular");
                driverTypes.add("aggresive");
                
                String name = new String("Scenario"+args[0]);

                int ret=JOptionPane.showConfirmDialog(null, "Do you want to specify a flow variations file?");
                
                if(ret==JOptionPane.OK_OPTION) {
                        JFileChooser fc=new JFileChooser(System.getProperty("user.home") + File.separatorChar + "maps" + 
                                        File.separatorChar + "variations");
                        fc.setDialogTitle("Choose the file specifying the flow variations");
                        int retVal=fc.showOpenDialog(null);
                        if(retVal==JFileChooser.APPROVE_OPTION) {
                                vnsim.map.object.Globals.variationsFile=fc.getSelectedFile().getName();
                        } else {
                                vnsim.map.object.Globals.variationsFile=null;   
                        }
                } else {
                        vnsim.map.object.Globals.variationsFile=null;   
                }
                //Scenario sc = getScenario(".//maps//map//"+args[0], entries, exits, driverTypes, route,name);
                Scenario sc = getScenario(System.getProperty("user.home") + File.separatorChar + "maps" + 
                                File.separatorChar + "map" + File.separatorChar + args[0], entries, exits, driverTypes, route,name);
                                

                
                GlobalNetwork.driverType = driverTypes;
                GlobalNetwork.name = name;
                //GlobalNetwork.mapName = ".//maps//map//"+args[0];
                GlobalNetwork.mapName = System.getProperty("user.home") + File.separatorChar + "maps" + 
                File.separatorChar + "map" + File.separatorChar + args[0];
                
                GlobalNetwork.entries = entries;
                GlobalNetwork.exits = exits;
                GlobalNetwork.socialMobility = mob;
                
                try 
                {
                        vnsim.vehicular.generator.Mobility.loadScenario(sc);
                } 
                catch (Exception ex) 
                {
                        JOptionPane.showMessageDialog(null, "<html>ERROR! Map structure has been modified<br> Try rebuilding the map " + sc.mapFileName +"!</html>");
                        throw ex;
                }
                
                vnsim.gui.Main.startGui();
                //vnsim.socialNet.startGraph.start();
        }
        
}