min_vel=5.,
max_vel=5.,
ds_min=5.,
ds_max=10.,
s_min=15.,
s_max=30.))
scenarios = \
ConfigWithEase(num_scenarios=3,
map_file_name="modules/runtime/tests/data/threeway_intersection.xodr",
random_seed=0,
params=param_server,
lane_corridor_configs=lane_corridors)
# viewer
viewer = MPViewer(params=param_server, use_world_bounds=True)
# viewer = Panda3dViewer(params=param_server,
# x_range=[-40, 40],
# y_range=[-40, 40],
# follow_agent_id=agent3.id)
# World Simulation
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.]
# viewer = VideoRenderer(renderer=viewer,
# world_step_time=sim_step_time,
xodr_parser = XodrParser("modules/runtime/tests/data/" + map_name + ".xodr")
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# World Definition
params = ParameterServer()
world = World(params)
map_interface = MapInterface()
map_interface.set_open_drive_map(xodr_parser.map)
world.set_map(map_interface)
open_drive_map = world.map.get_open_drive_map()
viewer = MPViewer(params=params, use_world_bounds=True)
viewer.drawWorld(world)
viewer.saveFig(output_dir + "/" + "world_plain.png")
color_triplet_gray = (0.7, 0.7, 0.7)
# Open Drive Elements (Roads, Lane Sections, Lanes)
for idx_r, road in open_drive_map.get_roads().items():
viewer.drawWorld(world)
viewer.drawRoad(road)
viewer.saveFig(output_dir + "/" + "open_drive_map_road_" + str(idx_r) +
".png")
viewer.clear()
for idx_r, road in open_drive_map.get_roads().items():
for idx_ls, lane_section in enumerate(road.lane_sections):
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
from modules.runtime.scenario.scenario_generation.uniform_vehicle_distribution import UniformVehicleDistribution
from modules.runtime.commons.parameters import ParameterServer
from modules.runtime.runtime import Runtime
from modules.runtime.viewer.matplotlib_viewer import MPViewer
from modules.runtime.viewer.video_renderer import VideoRenderer
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=10,
random_seed=0,
params=param_server)
viewer = MPViewer(params=param_server,
x_range=[5060, 5160],
y_range=[5070, 5150])
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]
scenario, idx = scenario_generation.get_next_scenario()
# Rendering WITHOUT intermediate steps
video_renderer = VideoRenderer(renderer=viewer, world_step_time=sim_step_time)
env = Runtime(0.2, video_renderer, scenario_generation, render=True)
env.reset()
for _ in range(0, 5):
env.step()
video_renderer.export_video(filename="examples/scenarios/test_video_step")
def test_uct_single_agent(self):
try:
from bark.models.behavior import BehaviorUCTSingleAgentMacroActions
except:
print("Rerun with --define planner_uct=true")
return
# World Definition
scenario_param_file = "macro_actions_test.json" # must be within examples params folder
params = ParameterServer(filename=os.path.join(
"modules/world/tests/params/", scenario_param_file))
world = World(params)
# Model Definitions
behavior_model = BehaviorUCTSingleAgentMacroActions(params)
execution_model = ExecutionModelInterpolate(params)
dynamic_model = SingleTrackModel(params)
behavior_model2 = BehaviorConstantVelocity(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, -5.25, 0, 20])
agent_params = params.AddChild("agent1")
# goal_polygon = Polygon2d(
# [1, 1, 0], [Point2d(0, 0), Point2d(0, 2), Point2d(2, 2), Point2d(2, 0)])
# goal_definition = GoalDefinitionPolygon(goal_polygon)
# goal_polygon = goal_polygon.Translate(Point2d(90, -2))
center_line = Line2d()
center_line.AddPoint(Point2d(0.0, -1.75))
center_line.AddPoint(Point2d(100.0, -1.75))
max_lateral_dist = (0.4, 0.5)
max_orientation_diff = (0.08, 0.1)
velocity_range = (5.0, 20.0)
goal_definition = GoalDefinitionStateLimitsFrenet(
center_line, max_lateral_dist, max_orientation_diff,
velocity_range)
agent = Agent(init_state, behavior_model, dynamic_model,
execution_model, agent_2d_shape, agent_params,
goal_definition, map_interface)
world.AddAgent(agent)
init_state2 = np.array([0, 25, -5.25, 0, 0])
agent2 = Agent(init_state2, behavior_model2, dynamic_model2,
execution_model2, agent_2d_shape, agent_params,
goal_definition, 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.2]
sim_real_time_factor = params["simulation"][
"real_time_factor", "execution in real-time or faster", 1]
# Draw map
video_renderer = VideoRenderer(renderer=viewer,
world_step_time=sim_step_time)
for _ in range(0, 5):
world.Step(sim_step_time)
viewer.clear()
video_renderer.drawWorld(world)
video_renderer.drawGoalDefinition(goal_definition)
time.sleep(sim_step_time / sim_real_time_factor)
video_renderer.export_video(filename="./test_video_intermediate",
remove_image_dir=True)
Point2d(1, -1)])
goal_polygon = goal_polygon.Translate(Point2d(-191.789, -50.1725))
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)
# viewer
viewer = MPViewer(params=param_server, use_world_bounds=True)
# World Simulation
sim_step_time = param_server["simulation"]["step_time",
"Step-time in simulation", 0.05]
sim_real_time_factor = param_server["simulation"][
"real_time_factor", "execution in real-time or faster", 100]
for _ in range(0, 10):
viewer.clear()
world.Step(sim_step_time)
viewer.drawWorld(world)
viewer.drawRoadCorridor(agent.road_corridor)
viewer.show(block=False)
time.sleep(sim_step_time / sim_real_time_factor)
execution_model,
agent_2d_shape,
agent_params,
2, # goal_lane_id
map_interface)
world.add_agent(agent)
# viewer
"""
viewer = PygameViewer(params=param_server,
x_range=[-50, 50],
y_range=[-50, 50],
follow_agent_id=agent.id,
screen_dims=[500, 500])
"""
viewer = MPViewer(params=param_server)
# World Simulation
sim_step_time = param_server["simulation"]["step_time",
"Step-time in simulation", 0.05]
sim_real_time_factor = param_server["simulation"][
"real_time_factor", "execution in real-time or faster", 100]
for _ in range(0, 100):
viewer.clear()
world.step(sim_step_time)
viewer.drawWorld(world)
viewer.show(block=False)
time.sleep(sim_step_time / sim_real_time_factor)
param_server.save(
agent_params = param_server.addChild("agent1")
agent1 = Agent(init_state, behavior_model, dynamic_model,
execution_model, agent_2d_shape, agent_params,
GoalDefinitionPolygon(goal_polygon), map_interface)
world.AddAgent(agent1)
agent_2d_shape2 = CarLimousine()
init_state2 = np.array([0, -15, -13, 3.14 * 3.0 / 4.0, 5.2])
agent_params2 = param_server.addChild("agent2")
agent2 = Agent(init_state2, behavior_model2, dynamic_model2, execution_model2,
agent_2d_shape2, agent_params2,
GoalDefinitionPolygon(goal_polygon), map_interface)
world.AddAgent(agent2)
# viewer
viewer = MPViewer(params=param_server, use_world_bounds=True)
# World Simulation
sim_step_time = param_server["simulation"]["step_time",
"Step-time used in simulation", 1]
sim_real_time_factor = param_server["simulation"][
"real_time_factor", "execution in real-time or faster", 1]
for _ in range(0, 10):
world.Step(sim_step_time)
viewer.drawWorld(world)
viewer.show(block=False)
time.sleep(sim_step_time / sim_real_time_factor)
param_server.save(
os.path.join(os.path.dirname(os.path.abspath(__file__)), "params",
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_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)
xodr_parser = XodrParser("modules/runtime/tests/data/" + map_name + ".xodr")
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# 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)
viewer.drawWorld(world)
viewer.saveFig(output_dir + "/" + "world_plain.png")
color_triplet_gray = (0.7,0.7,0.7)
# Open Drive Elements (XodrRoads, XodrLane Sections, XodrLanes)
# for idx_r, road in open_drive_map.GetRoads().items():
# viewer.drawWorld(world)
# viewer.drawXodrRoad(road)
# viewer.saveFig(output_dir + "/" + "open_drive_map_road_" + str(idx_r) + ".png")
# viewer.show(block=True)
# viewer.clear()
# for idx_r, road in open_drive_map.GetRoads().items():
# for idx_ls, lane_section in enumerate(road.lane_sections):
# https://opensource.org/licenses/MIT
# ffmpeg must be installed
from modules.runtime.scenario.scenario_generation.drone_challenge import DroneChallengeScenarioGeneration
from modules.runtime.commons.parameters import ParameterServer
from modules.runtime.viewer.matplotlib_viewer import MPViewer
from modules.runtime.viewer.video_renderer import VideoRenderer
import os
param_server = ParameterServer()
scenario_generation = DroneChallengeScenarioGeneration(num_scenarios=1,
random_seed=0,
params=param_server)
viewer = MPViewer(params=param_server, x_range=[-30, 30], y_range=[-30, 30])
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]
scenario, idx = scenario_generation.get_next_scenario()
# Rendering WITHOUT intermediate steps
video_renderer = VideoRenderer(renderer=viewer, world_step_time=sim_step_time)
for _ in range(0, 10): # run 5 scenarios in a row, repeating after 3
scenario, idx = scenario_generation.get_next_scenario()
world_state = scenario.get_world_state()
for _ in range(0, 5):
video_renderer.drawWorld(world_state, scenario._eval_agent_ids, idx)
world_state.step(sim_step_time)
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# ffmpeg must be installed
from modules.runtime.scenario.scenario_generation.drone_challenge import DroneChallengeScenarioGeneration
from modules.runtime.commons.parameters import ParameterServer
from modules.runtime.viewer.matplotlib_viewer import MPViewer
from modules.runtime.viewer.video_renderer import VideoRenderer
import os
param_server = ParameterServer()
scenario_generation = DroneChallengeScenarioGeneration(num_scenarios=3,
random_seed=0,
params=param_server)
viewer = MPViewer(params=param_server, x_range=[-30, 30], y_range=[-30, 30])
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]
scenario, idx = scenario_generation.get_next_scenario()
for _ in range(0, 5): # run 5 scenarios in a row, repeating after 3
scenario, idx = scenario_generation.get_next_scenario()
world = scenario.get_world_state()
# 20 steps
for _ in range(0, 20):
world.step(sim_step_time)
viewer.drawWorld(world)
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.set_open_drive_map(xodr_parser.map)
world.set_map(map_interface)
lane_sw = map_interface.find_lane(Point2d(46, 180))
assert lane_sw.lane_type == LaneType.sidewalk
lane_rl = map_interface.find_lane(Point2d(52, 130))
assert lane_rl.lane_type == LaneType.driving
lane_no_lane = map_interface.find_lane(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.set_open_drive_map(xodr_parser.map)
world.set_map(map_interface)
point = Point2d(5111, 5072)
viewer = MPViewer(params=params, use_world_bounds=True)
viewer.drawWorld(world)
polygon = world.map.get_roadgraph().get_lane_polygon_by_id(241)
polygon2 = world.map.get_roadgraph().get_lane_polygon_by_id(242)
viewer.drawPolygon2d(polygon, 'blue', 1.0)
viewer.drawPolygon2d(polygon2, 'green', 1.0)
viewer.drawPoint2d(point, 'red', 1.0)
viewer.show(block=True)
time.sleep(0.1)
lane_sw = map_interface.find_lane(point)
self.assertIsNotNone(lane_sw, "This point is clearly on a lane!")
try:
from bark.models.behavior import BehaviorUCTSingleAgent
except RuntimeError:
RuntimeError(
"BehaviorUCTSingleAgent not available, using ConstantVelocityModel")
scenario_param_file = "uct_planner.json" # must be within examples params folder
param_server = ParameterServer(
filename=os.path.join("examples/params/", scenario_param_file))
scenario_generation = UniformVehicleDistribution(num_scenarios=1,
random_seed=0,
params=param_server)
viewer = MPViewer(params=param_server,
x_range=[-16, 16],
y_range=[-2, 30],
follow_agent_id=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]
scenario, idx = scenario_generation.get_next_scenario()
world_state = scenario.get_world_state()
world_state.agents[scenario._eval_agent_ids[
0]].behavior_model = BehaviorUCTSingleAgent(param_server)
param_server.save("examples/params/mcts_params_written.json")
# world_state.agents[scenario._eval_agent_ids[0]].behavior_model
video_renderer = VideoRenderer(renderer=viewer,
# 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.get_next_scenario()
world_state = scenario.get_world_state()
print("Running scenario {} of {}".format(
idx, scenario_generation.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)
def test_dr_chn_merging(self):
# threeway_intersection
xodr_parser = XodrParser(
"modules/runtime/tests/data/DR_CHN_Merging_ZS_partial_v02.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.drawPolygon2d(road_corridor.lane_corridors[2].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.lane_corridors[2].polygon.Valid())
self.assertTrue(road_corridor.polygon.Valid())
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)
from modules.runtime.scenario.scenario_generation.configurable_scenario_generation import ConfigurableScenarioGeneration
from modules.runtime.commons.parameters import ParameterServer
from modules.runtime.viewer.matplotlib_viewer import MPViewer
from modules.runtime.runtime import Runtime
from modules.runtime.viewer.pygame_viewer import PygameViewer
import time
import os
scenario_param_file ="highway_merge_configurable.json" # must be within examples params folder
param_server = ParameterServer(filename= os.path.join("examples/params/",scenario_param_file))
scenario_generation = ConfigurableScenarioGeneration(num_scenarios=3, 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]
env = Runtime(0.2,
viewer,
scenario_generation,
render=True)
env.reset()
for _ in range(0, 5):
def test_python_behavior_model(self):
# World Definition
scenario_param_file = "macro_actions_test.json" # must be within examples params folder
params = ParameterServer(filename=os.path.join(
"modules/world/tests/params/", scenario_param_file))
world = World(params)
# Define two behavior models one python one standard c++ model
behavior_model = PythonDistanceBehavior(params)
execution_model = ExecutionModelInterpolate(params)
dynamic_model = SingleTrackModel(params)
behavior_model2 = BehaviorConstantVelocity(params)
execution_model2 = ExecutionModelInterpolate(params)
dynamic_model2 = SingleTrackModel(params)
# Define the map interface and load a testing map
map_interface = MapInterface()
xodr_map = MakeXodrMapOneRoadTwoLanes()
map_interface.SetOpenDriveMap(xodr_map)
world.SetMap(map_interface)
# Define the agent shapes
agent_2d_shape = CarRectangle()
init_state = np.array([0, 3, -5.25, 0, 20])
# Define the goal definition for agents
center_line = Line2d()
center_line.AddPoint(Point2d(0.0, -1.75))
center_line.AddPoint(Point2d(100.0, -1.75))
max_lateral_dist = (0.4, 0.5)
max_orientation_diff = (0.08, 0.1)
velocity_range = (5.0, 20.0)
goal_definition = GoalDefinitionStateLimitsFrenet(
center_line, max_lateral_dist, max_orientation_diff,
velocity_range)
# define two agents with the different behavior models
agent_params = params.AddChild("agent1")
agent = Agent(init_state, behavior_model, dynamic_model,
execution_model, agent_2d_shape, agent_params,
goal_definition, map_interface)
world.AddAgent(agent)
init_state2 = np.array([0, 25, -5.25, 0, 15])
agent2 = Agent(init_state2, behavior_model2, dynamic_model2,
execution_model2, agent_2d_shape, agent_params,
goal_definition, 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.2]
sim_real_time_factor = params["simulation"][
"real_time_factor", "execution in real-time or faster", 1]
# Draw map
video_renderer = VideoRenderer(renderer=viewer,
world_step_time=sim_step_time)
for _ in range(0, 20):
world.Step(sim_step_time)
viewer.clear()
video_renderer.drawWorld(world)
video_renderer.drawGoalDefinition(goal_definition, "red", 0.5,
"red")
time.sleep(sim_step_time / sim_real_time_factor)
video_renderer.export_video(filename="./test_video_intermediate",
remove_image_dir=True)
def test_database_run_and_analyze(self):
dbs = DatabaseSerializer(test_scenarios=4,
test_world_steps=5,
num_serialize_scenarios=10)
dbs.process("database")
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(maintain_history=True)
result.dump(os.path.join("./benchmark_results.pickle"))
result_loaded = BenchmarkResult.load(
os.path.join("./benchmark_results.pickle"))
params2 = ParameterServer()
fig = plt.figure(figsize=[10, 10])
viewer = MPViewer(params=params2,
center=[5112, 5165],
y_length=120,
enforce_y_length=True,
axis=fig.gca())
analyzer = BenchmarkAnalyzer(benchmark_result=result_loaded)
configs = analyzer.find_configs(criteria={
"behavior": lambda x: x == "IDM",
"success": lambda x: not x
})
configs_const = analyzer.find_configs(criteria={
"behavior": lambda x: x == "Const",
"success": lambda x: not x
})
#analyzer.visualize(configs_idx_list = configs,
# viewer = viewer, real_time_factor=10, fontsize=12)
plt.close(fig)
fig, (ax1, ax2) = plt.subplots(1, 2)
viewer1 = MPViewer(params=params2,
center=[5112, 5165],
y_length=120,
enforce_y_length=True,
axis=ax1)
viewer2 = MPViewer(params=params2,
center=[5112, 5165],
y_length=120,
enforce_y_length=True,
axis=ax2)
analyzer.visualize(configs_idx_list=[configs[1:3], configs_const[1:3]],
viewer=[viewer1, viewer2],
viewer_names=["IDM", "ConstVelocity"],
real_time_factor=1,
fontsize=12)
road_ids=[16],
lane_corridor_id=1,
controlled_ids=True)
# create 5 scenarios
scenarios = \
ConfigWithEase(
num_scenarios=5,
map_file_name="modules/runtime/tests/data/city_highway_straight.xodr",
random_seed=0,
params=param_server,
lane_corridor_configs=[left_lane, right_lane])
# viewer
viewer = MPViewer(params=param_server,
x_range=[-75, 75],
y_range=[-75, 75],
follow_agent_id=True)
sim_step_time = param_server["simulation"]["step_time",
"Step-time used in simulation",
0.05]
sim_real_time_factor = param_server["simulation"][
"real_time_factor", "execution in real-time or faster", 0.5]
# viewer = VideoRenderer(renderer=viewer,
# world_step_time=sim_step_time,
# fig_path="/home/hart/Dokumente/2020/bark/video")
# gym like interface
env = Runtime(step_time=0.2,
viewer=viewer,
map_interface)
world.add_agent(agent)
# viewer
viewer = PygameViewer(params=param_server,
x_range=[-50, 50],
y_range=[-50, 50],
follow_agent_id=agent.id,
screen_dims=[500, 500])
"""
viewer = Panda3dViewer(params=param_server,
x_range=[-150, 150],
y_range=[-150, 150],
follow_agent_id=agent.id)
"""
viewer = MPViewer(params=param_server)
# World Simulation
sim_step_time = param_server["simulation"]["step_time",
"Step-time in simulation", 0.05]
sim_real_time_factor = param_server["simulation"][
"real_time_factor", "execution in real-time or faster", 100]
for _ in range(0, 100):
viewer.clear()
world.step(sim_step_time)
viewer.drawWorld(world)
viewer.show(block=False)
time.sleep(sim_step_time / sim_real_time_factor)
param_server.save("examples/params/od8_const_vel_one_agent_written.json")
def test_three_way_intersection(self):
# threeway_intersection
xodr_parser = XodrParser(
"modules/runtime/tests/data/threeway_intersection.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)
comb_all = []
start_point = [Point2d(-30, -2)]
end_point_list = [Point2d(30, -2), Point2d(-2, -30)]
comb = list(itertools.product(start_point, end_point_list))
comb_all = comb_all + comb
# starting on the right
start_point = [Point2d(30, 2)]
end_point_list = [Point2d(-30, 2)]
comb = list(itertools.product(start_point, end_point_list))
comb_all = comb_all + comb
# starting on the bottom
start_point = [Point2d(2, -30)]
end_point_list = [Point2d(30, -2), Point2d(-30, 2)]
comb = list(itertools.product(start_point, end_point_list))
comb_all = comb_all + comb
# check few corridors
def GenerateRoadCorridor(map_interface, comb):
(start_p, end_p) = comb
polygon = Polygon2d([0, 0, 0], [
Point2d(-1, -1),
Point2d(-1, 1),
Point2d(1, 1),
Point2d(1, -1)
])
start_polygon = polygon.Translate(start_p)
goal_polygon = polygon.Translate(end_p)
rc = map_interface.GenerateRoadCorridor(start_p, goal_polygon)
return rc
# assert road ids
rc = GenerateRoadCorridor(map_interface, comb_all[0])
self.assertEqual(rc.road_ids, [0, 11, 1])
self.assertEqual(len(rc.lane_corridors), 3)
rc = GenerateRoadCorridor(map_interface, comb_all[1])
self.assertEqual(rc.road_ids, [0, 5, 2])
self.assertEqual(len(rc.lane_corridors), 3)
rc = GenerateRoadCorridor(map_interface, comb_all[2])
self.assertEqual(rc.road_ids, [1, 10, 0])
self.assertEqual(len(rc.lane_corridors), 3)
rc = GenerateRoadCorridor(map_interface, comb_all[3])
self.assertEqual(rc.road_ids, [2, 6, 1])
self.assertEqual(len(rc.lane_corridors), 3)
rc = GenerateRoadCorridor(map_interface, comb_all[4])
self.assertEqual(rc.road_ids, [2, 4, 0])
self.assertEqual(len(rc.lane_corridors), 3)
from modules.runtime.commons.parameters import ParameterServer
from modules.runtime.viewer.matplotlib_viewer import MPViewer
from modules.runtime.viewer.video_renderer import VideoRenderer
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=[-50, 50],
y_range=[-20, 80],
follow_agent_id=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]
scenario, idx = scenario_generation.get_next_scenario()
# Rendering WITHOUT intermediate steps
video_renderer = VideoRenderer(renderer=viewer, world_step_time=sim_step_time)
world_state = scenario.get_world_state()
for _ in range(0, 10): # run scenario for 100 steps
world_state.step(sim_step_time)
video_renderer.drawWorld(world_state, scenario._eval_agent_ids)
video_renderer.export_video(filename="examples/scenarios/test_video_step")
