def initScenario(self):
# Calculate maximum number of cars that can be accomodated in a lane
self.maxCarsInLane = int(
SCENE_CONSTS['ROAD_LENGTH'] /
(SCENE_CONSTS['CAR_LENGTH'] + SCENE_CONSTS['MIN_CAR_DISTANCE']))
if self.maxCarsInLane < 1:
raiseValueError("A lane should have atleast one car...")
# Check for valid number of lanes
if self.simArgs.getValue("lanes") < 2:
raiseValueError("number of lanes should be atleast two...")
# Calculate initial postion of the cars
startY = 5
self.startPoints = []
self.startPoints.append(startY)
for i in range(0, self.maxCarsInLane - 1):
startY += (SCENE_CONSTS['CAR_LENGTH'] +
SCENE_CONSTS['MIN_CAR_DISTANCE'])
self.startPoints.append(startY)
self.startPoints = np.array(self.startPoints)
assert len(self.startPoints) == self.maxCarsInLane
# Find the index for ego-vehicle
self.egoMidIndex = int(len(self.startPoints) / 2.0)
def searchLane(self, laneMap, vehID):
out = np.where(laneMap[0]['id'] == vehID)[0]
if len(out) > 0:
return 0
out = np.where(laneMap[1]['id'] == vehID)[0]
if len(out) > 0:
return 1
raiseValueError("vehicle with id:%d not found in any lane"%(vehID))
def generate(densities, numcars, numlanes, minAngles, numTrajec=1):
if numlanes != len(minAngles):
raiseValueError(
"size of minAngles should be equale to size of num of lanes")
laneMapDict = {}
for lane in range(0, numlanes):
laneMapDict[lane] = generateForLane(densities, numcars,
minAngles[lane], numTrajec)
return laneMapDict
def init(env):
#---- Check for only local view ----#
if env.gridHandler.isCommEnabled:
raiseValueError("Only Local View is supported in this mode.")
#---- Check for only local view ----#
#--- Generate Reverse Action Map ----#
reversedActMap = reverseDict(env.action_map)
#--- Generate Reverse Action Map ----#
return reversedActMap
def initLaneCoordinates(self):
self.laneCoordinates = []
if UI_CONSTS['CAR_WIDTH'] >= UI_CONSTS['LANE_WIDTH']:
raiseValueError("car length can't be greater than lane width...")
startPointX = UI_CONSTS['LANE_BOUNDARY_WIDTH']
endPointX = startPointX + UI_CONSTS['LANE_WIDTH']
for lane in range(0, self.simArgs.getValue("lanes")):
diff = (endPointX - startPointX)
point = int(startPointX + (diff / 2.0) - (UI_CONSTS['CAR_WIDTH']/2.0))
startPointX = endPointX + UI_CONSTS['LANE_BOUNDARY_WIDTH']
endPointX = startPointX + UI_CONSTS['LANE_WIDTH']
self.laneCoordinates.append(point)
def __init__(self, configPath):
self.configPath = configPath
print(self.configPath)
# Check if configFile exists or not
if not (checkFileExists(self.configPath)):
raiseValueError("Config file \"%s\" not found !")
# read Config yaml file
self.configDict = readYaml(self.configPath)["config"]
self.defautDict = deepcopy(DEFAULT_DICT)
# Merge the dicts to create a new one
self.mergeDict()
def __init__(self, config, mode, params=None):
# Parse Config file and return the handle
self.simArgs = configParser(config)
# Set render based on mode
if mode == "train":
self.simArgs.setValue("render", False)
else:
if params is not None:
for param in params.keys():
self.simArgs.setValue(param, params[param])
# Seed the random number generator
self.seed(self.simArgs.getValue("seed"))
# Set the observation size based on memory
if self.simArgs.getValue("enable-lstm"):
self.simArgs.setValue("k-frames", 1)
# Load Trajectories
currPath = os.path.realpath(__file__)[:-6]
self.trajecDict = loadPKL(currPath + 'src/data/trajec.pkl')
if self.trajecDict == None:
raiseValueError(
"no or invalid trajectory file found at v2i/src/data/")
'''
Append a list for 0.0 traffic density
'''
for lane in self.trajecDict.keys():
self.trajecDict[lane][0.0] = []
self.densities = list(self.trajecDict[0].keys())
# Fix issue2 for densities
self.trainDensities = self.fixIssue2v2(constants.DENSITIES)
# Initializes the required variables
self.init()
# Check for valid frame-skip-value
if self.simArgs.getValue("frame-skip-value") <= 0:
raiseValueError("frame skip value should be at least one")
# Info Dict
self.infoDict = self.buildInfoDict(self.densities)
def executeAction(self, action, laneMap, agentLane):
agentIDX = getAgentID(laneMap, agentLane)
distTravelledInDeg = 0
newSpeed = 0.0
if action == "acc":
distTravelledInDeg, newSpeed, collision, laneToChange = self.performAccelerate(
laneMap, agentLane, agentIDX)
elif action == "dec":
distTravelledInDeg, newSpeed, collision, laneToChange = self.performDecelerate(
laneMap, agentLane, agentIDX)
elif action == "do-nothing":
distTravelledInDeg, newSpeed, collision, laneToChange = self.performDoNothing(
laneMap, agentLane, agentIDX)
elif action == "lane-change":
distTravelledInDeg, newSpeed, collision, laneToChange = self.performLaneChange(
laneMap, agentLane, agentIDX)
else:
raiseValueError("%s is not a valid action !" % (action))
return distTravelledInDeg, newSpeed, collision, laneToChange
def drawInfoBoard(self, vehicles, planAction, commAction):
vehicle = getAgentObject(vehicles)
if vehicle is None:
raiseValueError("ego vehicle not found...")
startPointX = (UI_CONSTS['LANE_WIDTH'] + UI_CONSTS['LANE_BOUNDARY_WIDTH']) * self.simArgs.getValue('lanes') + 90
PointY = 10
agentLaneStr = "1. Agent lane : %d"%(vehicle[LANE_MAP_INDEX_MAPPING['lane']])
agentLaneStrText = self.str2font(agentLaneStr, self.fontNormal, self.colorBlack)
self.screen.blit(agentLaneStrText, (startPointX, PointY))
PointY += UI_CONSTS['INFO_BOARD_GAP']
agentSpeedStr = "2. Agent speed : %.2f km/hr"%(vehicle[LANE_MAP_INDEX_MAPPING['speed']] * 3.6)
agentSpeedStrText = self.str2font(agentSpeedStr, self.fontNormal, self.colorBlack)
self.screen.blit(agentSpeedStrText, (startPointX, PointY))
PointY += UI_CONSTS['INFO_BOARD_GAP']
agentPlanActStr = "3. Planner action : %s"%(str(planAction))
agentPlanActStrText = self.str2font(agentPlanActStr, self.fontNormal, self.colorBlack)
self.screen.blit(agentPlanActStrText, (startPointX, PointY))
PointY += UI_CONSTS['INFO_BOARD_GAP']
# Read config files
algoConfig = readYaml(args.training_algo_config)
simConfig = readYaml(args.sim_config)
# Build the ppo controller
trainAlgo = args.training_algo_config.split("/")[-1].split('-')[0].upper()
print(trainAlgo)
if trainAlgo == "IMPALA":
controller = impalaController(args.sim_config, algoConfig,
args.checkpoint_file)
elif trainAlgo == "PPO":
controller = ppoController(args.sim_config, algoConfig,
args.checkpoint_file)
else:
raiseValueError("invalid training algo %s" % (trainAlgo))
# Warn user if data save is not enabled
if (args.save_data != 1):
print(
info(
bold(
red("save is disabled, simulation data will not be saved to disk."
))))
# Local Env
env = V2I.V2I(args.sim_config, "test", paramDict(args))
# Init Render if enabled
fig, ax1, ax2 = None, None, None
if args.render_graphs == 1:
def setValue(self, key, value):
if key not in self.defautDict:
raiseValueError("Trying to access invalid key -> %s"%(key))
else:
self.defautDict[key] = value
def getValue(self, key):
if key not in self.defautDict:
raiseValueError("Trying to access invalid key -> %s"%(key))
else:
return self.defautDict[key]
def mergeDict(self):
for key in self.configDict.keys():
if key not in self.defautDict.keys():
raiseValueError("Invalid configuration key -> %s "%(key))
self.defautDict[key] = self.configDict[key]
def validateConfig(self, tfTrajecDict, tPeriod):
if tfTrajecDict["metadata"]["time-period"] != tPeriod:
raiseValueError("time-period doesn't match")
def reset(self, density=None): # expects a density list of size 2
density = self.fixIssue2(density)
# ---- Density Generation ----#
epsiodeDensity = None
if density == None:
epsiodeDensity = np.random.choice(self.trainDensities, size=2)
else:
if density[0] not in self.densities:
raiseValueError("invalid density for lane 0 -> %f" %
(density[0]))
if density[1] not in self.densities:
raiseValueError("invalid density for lane 1 -> %f" %
(density[1]))
epsiodeDensity = density
# ---- Density Generation ----#
# ---- Init variables ----#
self.time_elapsed = 0
self.num_cars = {}
self.num_trajec = {}
self.num_steps = 0
self.infoDict['totalEpisodes'] += 1
for lane in range(0, constants.LANES):
self.num_trajec[lane] = len(
self.trajecDict[lane][epsiodeDensity[lane]])
self.trajecIndex = {}
self.num_cars = {}
for lane in range(0, constants.LANES):
if self.num_trajec[lane] != 0:
self.trajecIndex[lane] = np.random.randint(
0, self.num_trajec[lane])
self.num_cars[lane] = len(self.trajecDict[lane][
epsiodeDensity[lane]][self.trajecIndex[lane]])
else:
self.trajecIndex[lane] = None
self.num_cars[lane] = 0
self.lane_map = self.buildlaneMap(self.trajecDict, self.trajecIndex,
epsiodeDensity, self.num_cars)
#print("Before Else : ")
#print(self.lane_map)
'''
Randomly Choose Agent Lane and Agent Car ID
'''
if epsiodeDensity[0] == 0.0 and epsiodeDensity[1] == 0.0:
for lane in range(0, constants.LANES):
if self.lane_map[lane].shape[0] == 1:
self.agent_lane = lane
self.lane_map[self.agent_lane][0]['agent'] = 1
else:
if epsiodeDensity[0] == 0.0:
self.agent_lane = 1
elif epsiodeDensity[1] == 0.0:
self.agent_lane = 0
else:
self.agent_lane = np.random.randint(0, constants.LANES)
self.randomIDX = np.random.randint(0,
self.num_cars[self.agent_lane])
self.lane_map[self.agent_lane][self.randomIDX]['agent'] = 1
self.lane_map[self.agent_lane][self.randomIDX][
'max-speed'] = self.simArgs.getValue('max-speed')
#---- Get Occupancy & Velocity Grids ----#
occGrid, velGrid = self.gridHandler.getGrids(self.lane_map,
self.agent_lane, 'null')
#---- Get Occupancy & Velocity Grids ----#
# ---- Set Traffic Light ----#
if self.simArgs.getValue("enable-tf"):
self.isLightRed = [False, False]
if np.random.rand() <= TF_CONSTS['EPISODE_TF_GEN_PROB']:
self.tfTogglePts = self.tfHandler.expandPts()
else:
self.tfTogglePts = [[], []]
# ---- Init variables ----#
if self.simArgs.getValue("render"):
if self.simArgs.getValue("enable-tf"):
self.uiHandler.updateScreen(
self.packRenderData(self.lane_map, self.time_elapsed,
self.agent_lane,
self.simArgs.getValue("max-speed"),
self.gridHandler.totalLocalView,
self.gridHandler.totalExtendedView,
occGrid, "none", "null", "none",
"none", "none"),
self.isLightRed,
)
else:
self.uiHandler.updateScreen(
self.packRenderData(self.lane_map, self.time_elapsed,
self.agent_lane,
self.simArgs.getValue("max-speed"),
self.gridHandler.totalLocalView,
self.gridHandler.totalExtendedView,
occGrid, "none", "null", "none",
"none", "none"), None)
# Reset Observation Queue
self.obsWrapper.resetQueue()
obs = self.buildObservation(occGrid, velGrid)
self.obsWrapper.addObs(obs)
return self.obsWrapper.getObs()
