def ipython_draw_html(po, outdir=None, area=None):
from IPython.display import IFrame, display
if outdir is None:
outdir = os.path.join(d, 'ipython_draw_html', '%s' % id(po))
draw_static(po, outdir, area=area)
iframe = IFrame(src=outdir + '/drawing.html', width='100%', height=600)
# noinspection PyTypeChecker
display(iframe)
return iframe
def ipython_draw_svg(m, outdir=None):
from IPython.display import SVG, display
if outdir is None:
outdir = os.path.join(d, 'ipython_draw_svg', '%s' % id(m))
draw_static(m, outdir)
svg = SVG(os.path.join(outdir, 'drawing.svg'))
# noinspection PyTypeChecker
display(svg)
return svg
def test_pose_sampling_1():
m = dw.load_map("4way")
along_lane = 0.2
only_straight = True
for i in range(45):
q = sample_good_starting_pose(m,
only_straight=only_straight,
along_lane=along_lane)
ground_truth = dw.SE2Transform.from_SE2(q)
m.set_object(f"sampled-{i}", dw.DB18(), ground_truth=ground_truth)
outdir = get_comptests_output_dir()
draw_static(m, outdir)
def make_scenario_main(args=None):
setup_logging()
parser = argparse.ArgumentParser()
parser.add_argument("--config", help="Configuration", required=True)
parser.add_argument("-o", "--output", help="Destination directory", required=True)
parser.add_argument("-n", "--num", type=int, help="Number of scenarios to generate", required=True)
parsed = parser.parse_args(args=args)
config: str = parsed.config
basename = os.path.basename(config).split(".")[0]
data = read_ustring_from_utf8_file(config)
interpreted = yaml.load(data, Loader=yaml.Loader)
n: int = parsed.num
output: str = parsed.output
params = object_from_ipce(interpreted, ScenarioGenerationParam, iedo=iedo)
for i in range(n):
scenario_name = f"{basename}-{i:03d}"
yaml_str = _get_map_yaml(params.map_name)
scenario = make_scenario(
yaml_str=yaml_str,
scenario_name=scenario_name,
only_straight=params.only_straight,
min_dist=params.min_dist,
delta_y_m=params.delta_y_m,
robots_npcs=params.robots_npcs,
robots_parked=params.robots_parked,
robots_pcs=params.robots_parked,
nduckies=params.nduckies,
duckie_min_dist_from_other_duckie=params.duckie_min_dist_from_other_duckie,
duckie_min_dist_from_robot=params.duckie_min_dist_from_robot,
duckie_y_bounds=params.duckie_y_bounds,
delta_theta_rad=np.deg2rad(params.theta_tol_deg),
)
scenario_struct = ipce_from_object(scenario, Scenario, ieso=ieso)
scenario_yaml = yaml.dump(scenario_struct)
filename = os.path.join(output, f"{scenario_name}.scenario.yaml")
write_ustring_to_utf8_file(scenario_yaml, filename)
dm = interpret_scenario(scenario)
output_dir = os.path.join(output, scenario_name)
dw.draw_static(dm, output_dir=output_dir)
export_gltf(dm, output_dir, background=False)
def make_scenario_main(args=None):
setup_logging()
parser = argparse.ArgumentParser()
# parser.add_argument("--config", help="Configuration", required=True)
parser.add_argument("-o",
"--output",
help="Destination directory",
required=True)
parser.add_argument("-n",
"--num",
type=int,
help="Number of scenarios to generate",
required=True)
parser.add_argument(
"--styles",
default="synthetic-F",
help=
"Draw preview in various styles, comma separated. (needs gym duckietown)",
)
parsed, rest = parser.parse_known_args(args=args)
if parsed.styles == "all":
styles = ["synthetic", "synthetic-F", "photos", "smooth"]
else:
styles = parsed.styles.split(",")
for config in rest:
basename = os.path.basename(config).split(".")[0]
data = read_ustring_from_utf8_file(config)
interpreted = yaml.load(data, Loader=yaml.Loader)
n: int = parsed.num
output: str = parsed.output
params: ScenarioGenerationParam = object_from_ipce(
interpreted, ScenarioGenerationParam, iedo=iedo)
for i in range(n):
scenario_name = f"{basename}-{i:03d}"
yaml_str = _get_map_yaml(params.map_name)
scenario = make_scenario(
yaml_str=yaml_str,
scenario_name=scenario_name,
only_straight=params.only_straight,
min_dist=params.min_dist,
delta_y_m=params.delta_y_m,
robots_npcs=params.robots_npcs,
robots_parked=params.robots_parked,
robots_pcs=params.robots_pcs,
nduckies=params.nduckies,
duckie_min_dist_from_other_duckie=params.
duckie_min_dist_from_other_duckie,
duckie_min_dist_from_robot=params.duckie_min_dist_from_robot,
duckie_y_bounds=params.duckie_y_bounds,
delta_theta_rad=np.deg2rad(params.theta_tol_deg),
pc_robot_protocol=params.pc_robot_protocol,
npc_robot_protocol=params.npc_robot_protocol,
tree_density=params.tree_density,
tree_min_dist=params.tree_min_dist,
)
# styles = ['smooth']
for style in styles:
try:
from gym_duckietown.simulator import Simulator
except ImportError:
logger.warning(traceback.format_exc())
# noinspection PyUnusedLocal
Simulator = None
else:
sim = Simulator(
"4way",
enable_leds=True,
domain_rand=False,
num_tris_distractors=0,
camera_width=640,
camera_height=480,
# distortion=True,
color_ground=[0, 0.3, 0], # green
style=style,
)
logger.info("resetting")
sim.reset()
m = cast(
dw.MapFormat1,
yaml.load(scenario.environment, Loader=yaml.Loader))
if "objects" not in m:
m["objects"] = {}
obs: Dict[str, object] = m["objects"]
for robot_name, srobot in scenario.robots.items():
st = dw.SE2Transform.from_SE2(
pose_from_friendly(srobot.configuration.pose))
obs[robot_name] = dict(kind="duckiebot",
pose=st.as_json_dict(),
height=0.12,
color=srobot.color)
for duckie_name, duckie in scenario.duckies.items():
st = dw.SE2Transform.from_SE2(
pose_from_friendly(duckie.pose))
obs[duckie_name] = dict(kind="duckie",
pose=st.as_json_dict(),
height=0.08,
color=duckie.color)
sim._interpret_map(m)
sim.reset()
logger.info("rendering obs")
img = sim.render_obs()
out = os.path.join(output, scenario_name, style, "cam.png")
save_rgb_to_png(img, out)
out = os.path.join(output, scenario_name, style, "cam.jpg")
save_rgb_to_jpg(img, out)
sim.cur_pos = [-100.0, -100.0, -100.0]
from gym_duckietown.simulator import FrameBufferMemory
td = FrameBufferMemory(width=1024, height=1024)
horiz = sim._render_img(
width=td.width,
height=td.height,
multi_fbo=td.multi_fbo,
final_fbo=td.final_fbo,
img_array=td.img_array,
top_down=True,
)
# img = sim.render("top_down")
out = cast(
FilePath,
os.path.join(output, scenario_name, style,
"top_down.jpg"))
save_rgb_to_jpg(horiz, out)
out = cast(
FilePath,
os.path.join(output, scenario_name, style,
"top_down.png"))
save_rgb_to_png(horiz, out)
dw.Tile.style = style
dm = interpret_scenario(scenario)
output_dir = os.path.join(output, scenario_name, style)
dw.draw_static(dm, output_dir=output_dir)
export_gltf(dm, output_dir, background=False)
scenario_struct = ipce_from_object(scenario, Scenario, ieso=ieso)
scenario_yaml = yaml.dump(scenario_struct)
filename = os.path.join(output, scenario_name, f"scenario.yaml")
write_ustring_to_utf8_file(scenario_yaml, filename)
def tag_positions():
map_yaml_data = yaml.load(map_yaml, Loader=yaml.Loader)
m = construct_map(map_yaml_data)
print(get_object_tree(m, attributes=True))
outdir = get_comptests_output_dir()
draw_static(m, outdir)
def test_pwm1():
parameters = get_DB18_nominal(delay=0)
# initial configuration
init_pose = np.array([0, 0.8])
init_vel = np.array([0, 0])
q0 = geo.SE2_from_R2(init_pose)
v0 = geo.se2_from_linear_angular(init_vel, 0)
tries = {
"straight_50": (PWMCommands(+0.5, 0.5)),
"straight_max": (PWMCommands(+1.0, +1.0)),
"straight_over_max": (PWMCommands(+1.5, +1.5)),
"pure_left": (PWMCommands(motor_left=-0.5, motor_right=+0.5)),
"pure_right": (PWMCommands(motor_left=+0.5, motor_right=-0.5)),
"slight-forward-left": (PWMCommands(motor_left=0, motor_right=0.25)),
"faster-forward-right": (PWMCommands(motor_left=0.5, motor_right=0)),
# 'slight-right': (PWMCommands(-0.1, 0.1)),
}
dt = 0.03
t_max = 10
map_data_yaml = """
tiles:
- [floor/W,floor/W, floor/W, floor/W, floor/W]
- [straight/W , straight/W , straight/W, straight/W, straight/W]
- [floor/W,floor/W, floor/W, floor/W, floor/W]
tile_size: 0.61
"""
map_data = yaml.load(map_data_yaml)
root = construct_map(map_data)
timeseries = {}
for id_try, commands in tries.items():
seq = integrate_dynamics(parameters, q0, v0, dt, t_max, commands)
ground_truth = seq.transform_values(
lambda t: SE2Transform.from_SE2(t[0]))
poses = seq.transform_values(lambda t: t[0])
velocities = get_velocities_from_sequence(poses)
linear = velocities.transform_values(linear_from_se2)
angular = velocities.transform_values(angular_from_se2)
# print(linear.values)
# print(angular.values)
root.set_object(id_try, DB18(), ground_truth=ground_truth)
sequences = {}
sequences["motor_left"] = seq.transform_values(
lambda _: commands.motor_left)
sequences["motor_right"] = seq.transform_values(
lambda _: commands.motor_right)
plots = TimeseriesPlot(f"{id_try} - PWM commands", "pwm_commands",
sequences)
timeseries[f"{id_try} - commands"] = plots
sequences = {}
sequences["linear_velocity"] = linear
sequences["angular_velocity"] = angular
plots = TimeseriesPlot(f"{id_try} - Velocities", "velocities",
sequences)
timeseries[f"{id_try} - velocities"] = plots
outdir = os.path.join(get_comptests_output_dir(), "together")
draw_static(root, outdir, timeseries=timeseries)
