def test_database_multiprocessing_runner(self):
dbs = DatabaseSerializer(test_scenarios=4,
test_world_steps=5,
num_serialize_scenarios=10)
dbs.process("data/database1")
local_release_filename = dbs.release(version="test")
db = BenchmarkDatabase(database_root=local_release_filename)
evaluators = {
"success": "EvaluatorGoalReached",
"collision": "EvaluatorCollisionEgoAgent",
"max_steps": "EvaluatorStepCount"
}
terminal_when = {
"collision": lambda x: x,
"max_steps": lambda x: x > 5
}
params = ParameterServer(
) # only for evaluated agents not passed to scenario!
behaviors_tested = {
"IDM": BehaviorIDMClassic(params),
"Const": BehaviorConstantVelocity(params)
}
benchmark_runner = BenchmarkRunnerMP(benchmark_database=db,
evaluators=evaluators,
terminal_when=terminal_when,
behaviors=behaviors_tested,
log_eval_avg_every=10)
result = benchmark_runner.run()
params2 = ParameterServer()
viewer = MPViewer(params=params2,
x_range=[5060, 5160],
y_range=[5070, 5150],
use_world_bounds=True)
rst, _ = benchmark_runner.run_benchmark_config(10, viewer=viewer)
rst = benchmark_runner.run(maintain_history=True)
self.assertEqual(len(rst.get_histories()), 40)
rst, scenario_history = benchmark_runner.run_benchmark_config(
11, viewer=None, maintain_history=True)
print(scenario_history)
viewer = MPViewer(params=params2,
x_range=[5060, 5160],
y_range=[5070, 5150],
use_world_bounds=True)
viewer.drawWorld(world=scenario_history[5].GetWorldState(),
eval_agent_ids=scenario_history[5].eval_agent_ids)
viewer.show(block=True)
df = result.get_data_frame()
print(df)
self.assertEqual(
len(df.index),
40) # 2 Behaviors * 10 Serialize Scenarios * 2 scenario sets
def test_tfa_runtime():
params = ParameterServer(
filename="tests/data/deterministic_scenario_test.json")
scenario_generation = DeterministicScenarioGeneration(num_scenarios=3,
random_seed=0,
params=params)
state_observer = ClosestAgentsObserver(params=params)
action_wrapper = DynamicModel(params=params)
evaluator = GoalReached(params=params)
viewer = MPViewer(params=params,
x_range=[-30, 30],
y_range=[-20, 40],
follow_agent_id=True) # use_world_bounds=True
runtimerl = RuntimeRL(action_wrapper=action_wrapper,
observer=state_observer,
evaluator=evaluator,
step_time=0.05,
viewer=viewer,
scenario_generator=scenario_generation)
tfa_env = TFAWrapper(runtimerl)
_ = tfa_env.reset()
utils.validate_py_environment(tfa_env, episodes=5)
_ = tf_py_environment.TFPyEnvironment(tfa_env)
def test_driving_corridor_adjacency_4way_intersection(self):
#xodr_parser = XodrParser("modules/runtime/tests/data/urban_road.xodr")
#xodr_parser = XodrParser("modules/runtime/tests/data/city_highway_straight.xodr")
xodr_parser = XodrParser("modules/runtime/tests/data/4way_intersection.xodr")
params = ParameterServer()
world = World(params)
map_interface = MapInterface()
map_interface.set_open_drive_map(xodr_parser.map)
map_interface.set_roadgraph(xodr_parser.roadgraph)
#xodr_parser.roadgraph.print_graph("/home/esterle/4way_intersection.dot")
world.set_map(map_interface)
map_interface.compute_all_driving_corridors()
all_corridors = map_interface.get_all_corridors()
c = all_corridors[10]
right_adj_corridors = map_interface.get_adjacent_corridors_same_direction(c, [151, 168, 0.0])
assert(len(right_adj_corridors) == 2)
right_adj_corridors = map_interface.get_adjacent_corridors_same_direction(c, [169, 169, 0.0])
assert(len(right_adj_corridors) == 1)
viewer = MPViewer(params=params)
viewer.drawWorld(world)
viewer.drawDrivingCorridor(c)
if right_adj_corridors:
for rc in right_adj_corridors:
viewer.drawDrivingCorridor(rc)
viewer.show(block=True)
time.sleep(0.1)
def test_motion_primitives_concat_state():
params = ParameterServer(
filename="modules/runtime/tests/data/highway_merging.json")
scenario_generation = UniformVehicleDistribution(num_scenarios=3,
random_seed=0,
params=params)
state_observer = StateConcatenation(params=params)
action_wrapper = MotionPrimitives(params=params)
evaluator = GoalReached(params=params)
viewer = MPViewer(params=params,
x_range=[-30, 30],
y_range=[-20, 40],
follow_agent_id=True) #use_world_bounds=True) #
runtimerl = RuntimeRL(action_wrapper=action_wrapper,
nn_observer=state_observer,
evaluator=evaluator,
step_time=0.05,
viewer=viewer,
scenario_generator=scenario_generation)
tfa_env = TFAWrapper(runtimerl)
_ = tfa_env.reset()
utils.validate_py_environment(tfa_env, episodes=5)
_ = tf_py_environment.TFPyEnvironment(tfa_env)
def test_find_lane(self):
xodr_parser = XodrParser("modules/runtime/tests/data/urban_road.xodr")
params = ParameterServer()
world = World(params)
map_interface = MapInterface()
map_interface.SetOpenDriveMap(xodr_parser.map)
world.SetMap(map_interface)
lane_sw = map_interface.FindLane(Point2d(46, 180))
assert lane_sw.lane_type == XodrLaneType.sidewalk
lane_rl = map_interface.FindLane(Point2d(52, 130))
assert lane_rl.lane_type == XodrLaneType.driving
lane_no_lane = map_interface.FindLane(Point2d(120, 140))
assert lane_no_lane == None
xodr_parser = XodrParser(
"modules/runtime/tests/data/city_highway_straight.xodr")
np.set_printoptions(precision=8)
params = ParameterServer()
world = World(params)
map_interface = MapInterface()
map_interface.SetOpenDriveMap(xodr_parser.map)
world.SetMap(map_interface)
point = Point2d(5114, 5072)
viewer = MPViewer(params=params, use_world_bounds=True)
viewer.drawWorld(world)
viewer.drawPoint2d(point, 'red', 1.0)
viewer.show(block=True)
time.sleep(0.1)
lane_sw = map_interface.FindLane(point)
self.assertIsNotNone(lane_sw, "This point is clearly on a lane!")
def test_driving_corridor_splitting_4way_intersection(self):
#xodr_parser = XodrParser("modules/runtime/tests/data/urban_road.xodr")
#xodr_parser = XodrParser("modules/runtime/tests/data/city_highway_straight.xodr")
xodr_parser = XodrParser("modules/runtime/tests/data/4way_intersection.xodr")
params = ParameterServer()
world = World(params)
map_interface = MapInterface()
map_interface.set_open_drive_map(xodr_parser.map)
# xodr_parser.roadgraph.print_graph("/home/esterle/4way_intersection.dot")
world.set_map(map_interface)
map_interface.compute_all_driving_corridors()
all_corridors = map_interface.get_all_corridors()
c = all_corridors[11]
splittingcorridors = map_interface.get_splitting_corridors(c, [168, 161, 0.0])
assert(len(splittingcorridors) == 0)
splittingcorridors = map_interface.get_splitting_corridors(c, [150, 168, 0.0])
assert(len(splittingcorridors) == 2)
viewer = MPViewer(params=params, use_world_bounds=True)
viewer.drawWorld(world)
viewer.drawDrivingCorridor(c)
if splittingcorridors:
for sc in splittingcorridors:
viewer.drawDrivingCorridor(sc)
viewer.show(block=True)
time.sleep(0.1)
def _build_configuration(self):
"""Builds a configuration using an SAC agent
"""
self._scenario_generator = \
DeterministicDroneChallengeGeneration(num_scenarios=3,
random_seed=0,
params=self._params)
self._observer = CustomObserver(params=self._params)
self._behavior_model = DynamicModel(model_name="TripleIntegratorModel",
params=self._params)
self._evaluator = CustomEvaluator(params=self._params)
viewer = MPViewer(params=self._params,
x_range=[-20, 20],
y_range=[-20, 20],
follow_agent_id=True)
self._viewer = viewer
# self._viewer = VideoRenderer(renderer=viewer, world_step_time=0.2)
self._runtime = RuntimeRL(action_wrapper=self._behavior_model,
observer=self._observer,
evaluator=self._evaluator,
step_time=0.2,
viewer=self._viewer,
scenario_generator=self._scenario_generator)
# tfa_env = tf_py_environment.TFPyEnvironment(TFAWrapper(self._runtime))
tfa_env = tf_py_environment.TFPyEnvironment(
parallel_py_environment.ParallelPyEnvironment(
[lambda: TFAWrapper(self._runtime)] * self._params["ML"]["Agent"]["num_parallel_environments"]))
self._agent = SACAgent(tfa_env, params=self._params)
self._runner = SACRunner(tfa_env,
self._agent,
params=self._params,
unwrapped_runtime=self._runtime)
def test_python_model(self):
param_server = ParameterServer(
filename="modules/runtime/tests/data/deterministic_scenario.json")
scenario_generation = DeterministicScenarioGeneration(num_scenarios=3,
random_seed=0,
params=param_server)
viewer = MPViewer(params=param_server,
follow_agent_id=False,
use_world_bounds=True)
env = Runtime(0.2,
viewer,
scenario_generation,
render=True)
single_track_model = SingleTrackModel(param_server)
behavior_model = DynamicBehaviorModel(single_track_model, param_server)
env.reset()
env._world.get_agent(0).behavior_model = behavior_model
env._world.get_agent(0).behavior_model.clone()
env.reset()
env._world.get_agent(0).behavior_model = behavior_model
env._world.get_agent(0).behavior_model.set_last_action(np.array([1., 2.]))
print(env._world.get_agent(0).behavior_model.get_last_action())
env._world.step(0.2)
print(env._world.get_agent(0).behavior_model.get_last_action())
def test_dr_deu_merging(self):
# threeway_intersection
xodr_parser = XodrParser(
"modules/runtime/tests/data/DR_DEU_Merging_MT_v01_shifted.xodr")
# World Definition
params = ParameterServer()
world = World(params)
map_interface = MapInterface()
map_interface.SetOpenDriveMap(xodr_parser.map)
world.SetMap(map_interface)
roads = [0, 1]
driving_direction = XodrDrivingDirection.forward
map_interface.GenerateRoadCorridor(roads, driving_direction)
road_corridor = map_interface.GetRoadCorridor(roads, driving_direction)
# Draw map
viewer = MPViewer(params=params, use_world_bounds=True)
viewer.drawWorld(world)
viewer.drawPolygon2d(road_corridor.lane_corridors[0].polygon,
color="blue",
alpha=0.5)
viewer.drawPolygon2d(road_corridor.lane_corridors[1].polygon,
color="blue",
alpha=0.5)
viewer.show(block=False)
self.assertTrue(road_corridor.lane_corridors[0].polygon.Valid())
self.assertTrue(road_corridor.lane_corridors[1].polygon.Valid())
self.assertTrue(road_corridor.polygon.Valid())
def _build_configuration(self):
"""Builds a configuration using an SAC agent
"""
self._scenario_generator = \
UniformVehicleDistribution(num_scenarios=20,
random_seed=0,
params=self._params)
self._observer = CustomObserver(params=self._params)
self._behavior_model = DynamicModel(params=self._params)
self._evaluator = CustomEvaluator(params=self._params)
self._viewer = MPViewer(params=self._params,
x_range=[-30, 30],
y_range=[-60, 20],
follow_agent_id=True)
#self._viewer = VideoRenderer(renderer=viewer, world_step_time=0.2)
self._runtime = RuntimeRL(action_wrapper=self._behavior_model,
observer=self._observer,
evaluator=self._evaluator,
step_time=0.2,
viewer=self._viewer,
scenario_generator=self._scenario_generator)
tfa_env = tf_py_environment.TFPyEnvironment(TFAWrapper(self._runtime))
self._agent_0 = SACAgent(tfa_env, params=self._params)
self._agent_1 = SACAgent(tfa_env, params=self._params)
self._runner = SACRunner(tfa_env, [self._agent_0, self._agent_1],
params=self._params,
unwrapped_runtime=self._runtime)
def test_motion_primitives_concat_state(self):
params = ParameterServer(
filename="tests/data/deterministic_scenario_test.json")
scenario_generation = DeterministicScenarioGeneration(num_scenarios=3,
random_seed=0,
params=params)
state_observer = SimpleObserver(params=params)
action_wrapper = MotionPrimitives(params=params)
evaluator = GoalReached(params=params)
viewer = MPViewer(params=params,
x_range=[-30, 30],
y_range=[-40, 40],
use_world_bounds=True)
runtimerl = RuntimeRL(action_wrapper=action_wrapper,
observer=state_observer,
evaluator=evaluator,
step_time=0.2,
viewer=viewer,
scenario_generator=scenario_generation,
render=False)
for _ in range(0, 3):
runtimerl.reset()
for _ in range(0, 50): # run each scenario for 10 steps
action = action_wrapper.action_space.sample()
next_observed_state, reward, done, info = \
runtimerl.step(action)
if done:
print("State: {} \n Reward: {} \n Done {}, Info: {} \n \
=================================================" . \
format(next_observed_state, reward, done, info))
break
def test_runner():
params = ParameterServer(
filename="tests/data/deterministic_scenario_test.json")
base_dir = os.path.dirname(os.path.dirname(__file__))
params["BaseDir"] = base_dir
scenario_generation = DeterministicScenarioGeneration(num_scenarios=3,
random_seed=0,
params=params)
state_observer = ClosestAgentsObserver(params=params)
action_wrapper = DynamicModel(params=params)
evaluator = GoalReached(params=params)
viewer = MPViewer(params=params,
x_range=[-30, 30],
y_range=[-20, 40],
follow_agent_id=True)
runtimerl = RuntimeRL(action_wrapper=action_wrapper,
observer=state_observer,
evaluator=evaluator,
step_time=0.2,
viewer=viewer,
scenario_generator=scenario_generation,
render=False)
tfa_env = tf_py_environment.TFPyEnvironment(TFAWrapper(runtimerl))
sac_agent = SACAgent(tfa_env, params=params)
tfa_runner = TFARunner(tfa_env,
sac_agent,
params=params,
unwrapped_runtime=runtimerl)
tfa_runner.collect_initial_episodes()
# main functionalities
tfa_runner.train()
tfa_runner.visualize()
tfa_runner.evaluate()
def test_bark_agent_in_runtime(self):
# check whether the bark agent really does work
params = ParameterServer(
filename="configurations/sac_highway/config.json")
configuration = SACHighwayConfiguration(params)
scenario_generator = configuration._scenario_generator
viewer = MPViewer(params=params,
x_range=[-50, 50],
y_range=[-50, 50],
follow_agent_id=100,
screen_dims=[500, 500],
use_world_bounds=False)
env = Runtime(0.2, viewer, scenario_generator, render=True)
env.reset()
dynamic_model = env._world.agents[
env._scenario._eval_agent_ids[0]].dynamic_model
bark_agent = BARKMLBehaviorModel(configuration, dynamic_model,
env._scenario._eval_agent_ids)
bark_agent.set_last_action(np.array([1., 0.]))
env._world.get_agent(
env._scenario._eval_agent_ids[0]).behavior_model = bark_agent
for _ in range(0, 35):
env.step()
def test_agent(self):
params = ParameterServer(
filename="tests/data/deterministic_scenario_test.json")
base_dir = os.path.dirname(os.path.dirname(__file__))
params["BaseDir"] = base_dir
scenario_generation = DeterministicScenarioGeneration(num_scenarios=2,
random_seed=0,
params=params)
state_observer = ClosestAgentsObserver(params=params)
action_wrapper = DynamicModel(params=params)
evaluator = GoalReached(params=params)
viewer = MPViewer(params=params,
x_range=[-30, 30],
y_range=[-20, 40],
follow_agent_id=True) # use_world_bounds=True
runtimerl = RuntimeRL(action_wrapper=action_wrapper,
observer=state_observer,
evaluator=evaluator,
step_time=0.05,
viewer=viewer,
scenario_generator=scenario_generation)
tfa_env = tf_py_environment.TFPyEnvironment(TFAWrapper(runtimerl))
sac_agent = SACAgent(tfa_env, params=params)
self.assertEqual(sac_agent._agent.name, "sac_agent")
sac_agent.reset()
# TODO(@hart): does not work because of read-only file-system
# sac_agent.save()
sac_agent.load()
def test_road_corridor_forward(self):
xodr_parser = XodrParser(
"modules/runtime/tests/data/road_corridor_test.xodr")
# World Definition
params = ParameterServer()
world = World(params)
map_interface = MapInterface()
map_interface.SetOpenDriveMap(xodr_parser.map)
world.SetMap(map_interface)
open_drive_map = world.map.GetOpenDriveMap()
viewer = MPViewer(params=params, use_world_bounds=True)
# Draw map
viewer.drawWorld(world)
viewer.show(block=False)
# Generate RoadCorridor
roads = [0, 1, 2]
driving_direction = XodrDrivingDirection.forward
map_interface.GenerateRoadCorridor(roads, driving_direction)
road_corridor = map_interface.GetRoadCorridor(roads, driving_direction)
# Assert road corridor
# Assert: 3 roads
self.assertEqual(len(road_corridor.roads), 3)
# Assert: road1: 2 lanes, road2: 1 lane, road3: 1 lane
self.assertEqual(len(road_corridor.GetRoad(0).lanes), 3)
self.assertEqual(len(road_corridor.GetRoad(1).lanes), 2)
self.assertEqual(len(road_corridor.GetRoad(2).lanes), 3)
# Assert: next road
self.assertEqual(road_corridor.GetRoad(0).next_road.road_id, 1)
self.assertEqual(road_corridor.GetRoad(1).next_road.road_id, 2)
# Assert: lane links
self.assertEqual(
road_corridor.GetRoad(0).GetLane(3).next_lane.lane_id, 5)
self.assertEqual(
road_corridor.GetRoad(1).GetLane(5).next_lane.lane_id, 8)
# Assert: LaneCorridor
self.assertEqual(len(road_corridor.lane_corridors), 3)
colors = ["blue", "red", "green"]
count = 0
for lane_corridor in road_corridor.lane_corridors:
viewer.drawPolygon2d(lane_corridor.polygon,
color=colors[count],
alpha=0.5)
viewer.drawLine2d(lane_corridor.left_boundary, color="red")
viewer.drawLine2d(lane_corridor.right_boundary, color="blue")
viewer.drawLine2d(lane_corridor.center_line, color="black")
viewer.show(block=False)
plt.pause(2.)
count += 1
def test_lane_change(self):
# World Definition
params = ParameterServer()
world = World(params)
# Model Definitions
behavior_model = BehaviorMobil(params)
execution_model = ExecutionModelInterpolate(params)
dynamic_model = SingleTrackModel(params)
behavior_model2 = BehaviorIDMLaneTracking(params)
execution_model2 = ExecutionModelInterpolate(params)
dynamic_model2 = SingleTrackModel(params)
# Map Definition
map_interface = MapInterface()
xodr_map = MakeXodrMapOneRoadTwoLanes()
map_interface.SetOpenDriveMap(xodr_map)
world.SetMap(map_interface)
#agent_2d_shape = CarLimousine()
agent_2d_shape = CarRectangle()
init_state = np.array([0, 3, -1.75, 0, 5])
agent_params = params.AddChild("agent1")
goal_polygon = Polygon2d(
[1, 1, 0],
[Point2d(0, 0),
Point2d(0, 2),
Point2d(2, 2),
Point2d(2, 0)])
goal_polygon = goal_polygon.Translate(Point2d(50, -2))
agent = Agent(init_state, behavior_model, dynamic_model,
execution_model, agent_2d_shape, agent_params,
GoalDefinitionPolygon(goal_polygon), map_interface)
world.AddAgent(agent)
init_state2 = np.array([0, 15, -1.75, 0, 2])
agent2 = Agent(init_state2, behavior_model2, dynamic_model2,
execution_model2, agent_2d_shape, agent_params,
GoalDefinitionPolygon(goal_polygon), map_interface)
world.AddAgent(agent2)
# viewer
viewer = MPViewer(params=params, use_world_bounds=True)
# World Simulation
sim_step_time = params["simulation"]["step_time",
"Step-time in simulation", 0.05]
sim_real_time_factor = params["simulation"][
"real_time_factor", "execution in real-time or faster", 100]
# Draw map
for _ in range(0, 10):
viewer.clear()
world.Step(sim_step_time)
viewer.drawWorld(world)
viewer.show(block=False)
time.sleep(sim_step_time / sim_real_time_factor)
def test_runtime_rl(self):
params = ParameterServer(
filename="tests/data/deterministic_scenario_test.json")
scenario_generation = DeterministicScenarioGeneration(num_scenarios=2,
random_seed=0,
params=params)
state_observer = SimpleObserver(params=params)
action_wrapper = DynamicModel(params=params)
evaluator = GoalReached(params=params)
viewer = MPViewer(params=params,
x_range=[-30, 30],
y_range=[-40, 40],
use_world_bounds=True) #use_world_bounds=True) #
runtimerl = RuntimeRL(action_wrapper=action_wrapper,
observer=state_observer,
evaluator=evaluator,
step_time=0.2,
viewer=viewer,
scenario_generator=scenario_generation,
render=False)
start_time = time.time()
for _ in range(0, 100):
runtimerl.reset()
done = False
reward = 0.
for _ in range(0, 50): # run each scenario for 10 steps
action = action_wrapper.action_space.sample(
) / 100 # to go straight
next_observed_state, reward, done, info = \
runtimerl.step(action)
# observer
self.assertEqual(len(next_observed_state), 16)
np.testing.assert_array_equal(
next_observed_state[0:4],
state_observer._normalize(
runtimerl._world.agents[100].state)[1:5])
np.testing.assert_array_equal(
next_observed_state[4:8],
state_observer._normalize(
runtimerl._world.agents[101].state)[1:5])
if done:
print("State: {} \n Reward: {} \n Done {}, Info: {} \n \
=================================================" . \
format(next_observed_state, reward, done, info))
break
# must assert to equal as the agent reaches the goal in the
# specified number of steps
self.assertEqual(done, True)
# goal must have been reached which returns a reward of 1.
self.assertEqual(reward, 1.)
self.assertEqual(runtimerl._world.agents[100].id, 100)
self.assertEqual(runtimerl._world.agents[101].id, 101)
end_time = time.time()
print("100 runs took {}s.".format(str(end_time - start_time)))
def _build_configuration(self):
"""Builds a configuration using an SAC agent
"""
# TODO(@hart): increase scenario number
self._scenario_generator = \
ConfigurableScenarioGeneration(num_scenarios=100,
params=self._params)
# USE THIS FOR DETERMINISTIC SCENARIO GEN.
# self._scenario_generator = \
# DeterministicScenarioGeneration(num_scenarios=100,
# params=self._params)
# self._observer = NearestObserver(self._params)
self._observer = ClosestAgentsObserver(self._params)
self._behavior_model = DynamicModel(params=self._params)
self._evaluator = CustomEvaluator(params=self._params)
sim_step_time = 0.2
real_time_factor = 5
resolution = (1920, 1080)
dpi = 300
fig_env = plt.figure(figsize=(resolution[0] / dpi,
resolution[1] / dpi),
dpi=dpi)
gs = gridspec.GridSpec(1, 1, left=0.0, right=1, bottom=0, top=0.9)
axis = plt.subplot(gs[0])
viewer = MPViewer(params=self._params,
y_length=80,
enforce_y_length=True,
enforce_x_length=False,
follow_agent_id=True,
axis=axis)
# self._viewer = VideoRenderer(renderer=viewer, world_step_time=0.2)
self._viewer = viewer
self._runtime = RuntimeRL(action_wrapper=self._behavior_model,
observer=self._observer,
evaluator=self._evaluator,
step_time=0.2,
viewer=self._viewer,
scenario_generator=self._scenario_generator)
tfa_env = tf_py_environment.TFPyEnvironment(TFAWrapper(self._runtime))
eval_tf_env = tf_py_environment.TFPyEnvironment(
TFAWrapper(self._runtime))
# self._agent = PPOAgent(tfa_env, params=self._params)
# self._runner = PPORunner(tfa_env,
# eval_tf_env,
# self._agent,
# params=self._params,
# unwrapped_runtime=self._runtime)
self._agent = SACAgent(tfa_env, params=self._params)
self._runner = SACRunner(tfa_env,
self._agent,
params=self._params,
unwrapped_runtime=self._runtime)
def test_runtime(self):
"""Asserts the runtime to make sure the basic
functionality is given by the current state of BARK.
"""
param_server = ParameterServer(
filename="tests/data/deterministic_scenario_test.json")
scenario_generation = DeterministicScenarioGeneration(num_scenarios=3,
random_seed=0,
params=param_server)
param_server["Visualization"]["Agents"]["DrawRoute",
"Draw the local map of each agent",
True]
viewer = MPViewer(params=param_server,
use_world_bounds=True)
env = Runtime(0.2,
viewer,
scenario_generation,
render=True)
env.reset()
agent_ids = []
agent_states = []
centers_of_driving_corridor= []
for key, agent in env._world.agents.items():
agent_ids.append(agent.id)
agent_states.append(agent.state)
for i in range(0, 5):
print("Scenario {}:".format(
str(env._scenario_generator._current_scenario_idx)))
# assert scenario ids
self.assertEqual(env._scenario_generator._current_scenario_idx, (i % 3) + 1)
for _ in range(0, 35):
# assert ids
states_before = []
for i, (key, agent) in enumerate(env._world.agents.items()):
self.assertEqual(key, agent.id)
self.assertEqual(agent_ids[i], agent.id)
states_before.append(agent.state)
# TODO(@hart): why does this not work
print(key, agent.goal_definition.goal_shape)
env.step()
# assert state has been changed by the step() function
for i, (key, agent) in enumerate(env._world.agents.items()):
np.testing.assert_equal(np.any(np.not_equal(states_before[i],
agent.state)), True)
# check whether the reset works
env.reset()
for i, (key, agent) in enumerate(env._world.agents.items()):
self.assertEqual(key, agent.id)
self.assertEqual(agent_ids[i], agent.id)
np.testing.assert_array_equal(agent_states[i], agent.state)
def test_python_model_inheritance(self):
param_server = ParameterServer(
filename="modules/runtime/tests/data/deterministic_scenario.json")
scenario_generation = DeterministicScenarioGeneration(
num_scenarios=3, random_seed=0, params=param_server)
viewer = MPViewer(params=param_server,
follow_agent_id=False,
use_world_bounds=True)
scenario, idx = scenario_generation.get_next_scenario()
world = scenario.get_world_state()
behavior_model = PythonBehaviorModelWrapperInheritance(param_server)
world.GetAgent(0).behavior_model = behavior_model
world.GetAgent(0).behavior_model.SetLastAction(
np.array([1., 1.], dtype=np.float32))
world.Step(0.2)
def test_visualization(self):
param_server = ParameterServer(
filename="modules/runtime/tests/data/deterministic_scenario.json")
scenario_generation = DeterministicScenarioGeneration(
num_scenarios=3, random_seed=0, params=param_server)
viewer = MPViewer(params=param_server,
follow_agent_id=False,
use_world_bounds=True)
env = Runtime(0.2, viewer, scenario_generation, render=True)
env.reset()
for _ in range(0, 5):
print("Scenario {}:".format(
str(env._scenario_generator._current_scenario_idx)))
for _ in range(0, 5):
env.step()
env.reset()
def test_two_roads_one_lane(self):
xodr_map = MakeXodrMapOneRoadTwoLanes()
# World Definition
params = ParameterServer()
world = World(params)
map_interface = MapInterface()
map_interface.SetOpenDriveMap(xodr_map)
world.SetMap(map_interface)
open_drive_map = world.map.GetOpenDriveMap()
viewer = MPViewer(params=params, use_world_bounds=True)
# Draw map
viewer.drawWorld(world)
viewer.show(block=False)
# Generate RoadCorridor
roads = [100]
driving_direction = XodrDrivingDirection.forward
map_interface.GenerateRoadCorridor(roads, driving_direction)
road_corridor = map_interface.GetRoadCorridor(roads, driving_direction)
# Assert road corridor
# Assert: 1 road
self.assertEqual(len(road_corridor.roads), 1)
# Assert: road1: 2 lanes
self.assertEqual(len(road_corridor.GetRoad(roads[0]).lanes), 3)
colors = ["blue", "red", "green"]
count = 0
for lane_corridor in road_corridor.lane_corridors:
viewer.drawPolygon2d(lane_corridor.polygon,
color=colors[count],
alpha=0.5)
viewer.drawLine2d(lane_corridor.left_boundary, color="red")
viewer.drawLine2d(lane_corridor.right_boundary, color="blue")
viewer.drawLine2d(lane_corridor.center_line, color="black")
viewer.show(block=False)
plt.pause(2.)
count += 1
viewer.show(block=True)
def test_python_model(self):
param_server = ParameterServer(
filename="modules/runtime/tests/data/deterministic_scenario.json")
scenario_generation = DeterministicScenarioGeneration(num_scenarios=3,
random_seed=0,
params=param_server)
viewer = MPViewer(params=param_server,
follow_agent_id=False,
use_world_bounds=True)
env = Runtime(0.2,
viewer,
scenario_generation,
render=True)
behavior_model = DummyBehaviorModel(param_server)
env.reset()
env._world.get_agent(0).behavior_model = behavior_model
env._world.get_agent(0).behavior_model.clone()
np.testing.assert_array_equal(
env._world.get_agent(0).behavior_model.plan(0.2, env._world)[1],
np.array([0.2, 5111.626, 5106.8305 + 0.2, 1.5, 10]))
env.reset()
env._world.get_agent(0).behavior_model = behavior_model
env._world.step(0.2)
np.testing.assert_array_equal(
env._world.get_agent(0).state,
np.array([0.2, 5111.626, 5106.8305 + 0.2, 1.5, 10], dtype=np.float32))
env._world.step(0.2)
np.testing.assert_array_equal(
env._world.get_agent(0).state,
np.array([0.4, 5111.626, 5106.8305 + 0.4, 1.5, 10], dtype=np.float32))
env._world.step(0.2)
np.testing.assert_array_equal(
env._world.get_agent(0).state,
np.array([0.6, 5111.626, 5106.8305 + 0.6, 1.5, 10], dtype=np.float32))
print("History:", env._world.get_agent(0).history)
# environment loop
env.reset()
for i in range(0, 7):
env.step()
def test_road_corridor_intersection(self):
xodr_parser = XodrParser(
"modules/runtime/tests/data/road_corridor_test.xodr")
# World Definition
params = ParameterServer()
world = World(params)
map_interface = MapInterface()
map_interface.SetOpenDriveMap(xodr_parser.map)
world.SetMap(map_interface)
open_drive_map = world.map.GetOpenDriveMap()
viewer = MPViewer(params=params, use_world_bounds=True)
# Draw map
viewer.drawWorld(world)
viewer.show(block=False)
# Generate RoadCorridor
roads = [0, 1, 2]
driving_direction = XodrDrivingDirection.forward
map_interface.GenerateRoadCorridor(roads, driving_direction)
road_corridor = map_interface.GetRoadCorridor(roads, driving_direction)
colors = ["blue", "red", "green", "yellow"]
count = 0
for road_id, road in road_corridor.roads.items():
for lane_id, lane in road.lanes.items():
print(road_id, lane_id, lane.driving_direction)
for lane_corridor in road_corridor.lane_corridors:
viewer.drawPolygon2d(lane_corridor.polygon,
color=colors[count],
alpha=0.5)
viewer.drawLine2d(lane_corridor.left_boundary, color="red")
viewer.drawLine2d(lane_corridor.right_boundary, color="blue")
viewer.drawLine2d(lane_corridor.center_line, color="black")
viewer.show(block=False)
plt.pause(0.5)
count += 1
viewer.show(block=True)
def test_motion_primitives_concat_state(self):
params = ParameterServer(
filename="modules/runtime/tests/data/highway_merging.json")
scenario_generation = UniformVehicleDistribution(num_scenarios=3,
random_seed=0,
params=params)
state_observer = StateConcatenation(params=params)
action_wrapper = MotionPrimitives(params=params)
evaluator = GoalReached(params=params)
viewer = MPViewer(params=params,
x_range=[-30, 30],
y_range=[-20, 40],
follow_agent_id=True) #use_world_bounds=True) #
runtimerl = RuntimeRL(action_wrapper=action_wrapper,
nn_observer=state_observer,
evaluator=evaluator,
step_time=0.05,
viewer=viewer,
scenario_generator=scenario_generation)
for _ in range(0, 5): # run 5 scenarios in a row, repeating after 3
nn_state = runtimerl.reset()
i = 0
actionsteps = []
for _ in range(0, 1000): # run each scenario for 1000 steps
actionstep = action_wrapper.action_space.sample()
next_nn_state, reward, done, info = runtimerl.step(actionstep)
actionsteps.append(actionstep)
i += 1
runtimerl.render()
if info["success"] or done:
print("Finish in ", i)
print("Actions taken:", actionsteps)
print("State: {} \n Reward: {} \n Done {}, Info: {} \n \
=================================================".
format(next_nn_state, reward, done, info))
break
params.save(filename="highway_merging_written.json")
def test_two_roads_one_lane(self):
params = ParameterServer()
world = World(params)
xodr_map = MakeXodrMapOneRoadTwoLanes()
map_interface = MapInterface()
map_interface.SetOpenDriveMap(xodr_map)
world.SetMap(map_interface)
start_point = Point2d(0, -11)
lanes_near_start = map_interface.find_nearest_lanes(start_point, 1)
assert(len(lanes_near_start) == 1)
goal_point = Point2d(-191.789, -50.1725)
lanes_near_goal = map_interface.find_nearest_lanes(goal_point, 1)
assert(len(lanes_near_goal) == 1)
viewer = MPViewer(params=params, use_world_bounds=True)
viewer.drawWorld(world)
time.sleep(2) # if this is not here, the second unit test is not executed (maybe parsing takes too long?)
# Copyright (c) 2019 fortiss GmbH
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
from load.benchmark_database import BenchmarkDatabase
from modules.runtime.viewer.matplotlib_viewer import MPViewer
from modules.runtime.commons.parameters import ParameterServer
import time
db = BenchmarkDatabase(database_root="external/benchmark_database_release")
scenario_generation = db.get_scenario_generator(scenario_set_id=0)
param_server = ParameterServer()
viewer = MPViewer(params=param_server,
x_range=[5060, 5160],
y_range=[5070, 5150])
for _ in range(0, 5): # run 5 scenarios in a row, repeating after 3
scenario, idx = scenario_generation[0].get_next_scenario()
world_state = scenario.get_world_state()
print("Running scenario {} of {}".format(
idx, scenario_generation[0].num_scenarios))
for _ in range(0, 10): # run each scenario for 3 steps
world_state.step(0.2)
viewer.drawWorld(world_state)
viewer.show(block=False)
time.sleep(0.2)
from modules.runtime.scenario.scenario_generation.uniform_vehicle_distribution import UniformVehicleDistribution
from modules.runtime.commons.parameters import ParameterServer
from modules.runtime.viewer.matplotlib_viewer import MPViewer
from modules.runtime.viewer.pygame_viewer import PygameViewer
import time
import os
scenario_param_file = "highway_merging.json" # must be within examples params folder
param_server = ParameterServer(
filename=os.path.join("examples/params/", scenario_param_file))
scenario_generation = UniformVehicleDistribution(num_scenarios=3,
random_seed=0,
params=param_server)
viewer = MPViewer(params=param_server,
x_range=[5060, 5160],
y_range=[5070, 5150],
use_world_bounds=True)
sim_step_time = param_server["simulation"]["step_time",
"Step-time used in simulation", 0.2]
sim_real_time_factor = param_server["simulation"][
"real_time_factor", "execution in real-time or faster", 1]
# TODO(@hart): does not work with bazel test //... because of read only file-system
# scenario_generation.dump_scenario_list(filename="examples/scenarios/highway_merging_dump.bark_scenarios")
# load scenario list
scenario_generation.load_scenario_list(
filename="examples/scenarios/highway_merging_dump.bark_scenarios")
for _ in range(0, 5): # run 5 scenarios in a row, repeating after 3
scenario, idx = scenario_generation.get_next_scenario()
# some path magic
base_dir = "/home/hart/Dokumente/2020/bark-ml"
params = ParameterServer(filename=base_dir +
"/configurations/highway/config.json")
scenario_generation = params["Scenario"]["Generation"][
"ConfigurableScenarioGeneration"]
map_filename = scenario_generation["MapFilename"]
scenario_generation["MapFilename"] = base_dir + "/" + map_filename
params["BaseDir"] = base_dir
# actual model
ml_config = HighwayConfiguration(params)
ml_behavior = BARKMLBehaviorModel(configuration=ml_config)
scenario_generator = ml_config._scenario_generator
viewer = MPViewer(params=params, use_world_bounds=True)
env = Runtime(0.2, viewer, scenario_generator, render=True)
env.reset()
env._world.agents[
env._scenario._eval_agent_ids[0]].behavior_model = ml_behavior
print(ml_behavior)
for _ in range(0, 50):
env.step()
# to find database files
os.chdir("../benchmark_database/")
dbs = DatabaseSerializer(test_scenarios=4,
test_world_steps=5,
def test_evaluator_drivable_area(self):
# World Definition
params = ParameterServer()
world = World(params)
# Model Definitions
behavior_model = BehaviorConstantVelocity(params)
execution_model = ExecutionModelInterpolate(params)
dynamic_model = SingleTrackModel(params)
# Map Definition
map_interface = MapInterface()
xodr_map = MakeXodrMapOneRoadTwoLanes()
map_interface.SetOpenDriveMap(xodr_map)
world.SetMap(map_interface)
#open_drive_map = world.map.GetOpenDriveMap()
#agent_2d_shape = CarLimousine()
agent_2d_shape = Polygon2d(
[1.25, 1, 0],
[Point2d(-1, -1),
Point2d(-1, 1),
Point2d(3, 1),
Point2d(3, -1)])
init_state = np.array([0, 3, -1.75, 0, 5])
agent_params = params.AddChild("agent1")
goal_polygon = Polygon2d(
[1, 1, 0],
[Point2d(0, 0),
Point2d(0, 2),
Point2d(2, 2),
Point2d(2, 0)])
goal_polygon = goal_polygon.Translate(Point2d(50, -2))
agent = Agent(
init_state,
behavior_model,
dynamic_model,
execution_model,
agent_2d_shape,
agent_params,
GoalDefinitionPolygon(goal_polygon), # goal_lane_id
map_interface)
world.AddAgent(agent)
evaluator = EvaluatorDrivableArea()
world.AddEvaluator("drivable_area", evaluator)
info = world.Evaluate()
self.assertFalse(info["drivable_area"])
viewer = MPViewer(params=params, use_world_bounds=True)
# Draw map
viewer.drawGoalDefinition(goal_polygon,
color=(1, 0, 0),
alpha=0.5,
facecolor=(1, 0, 0))
viewer.drawWorld(world)
viewer.drawRoadCorridor(agent.road_corridor)
viewer.show(block=False)
