def main():
parser = create_parser()
parser.add_argument('-enable', action='store_true', help='Enables rendering during planning')
parser.add_argument('-teleport', action='store_true', help='Teleports between configurations')
parser.add_argument('-simulate', action='store_true', help='Simulates the system')
parser.add_argument('-viewer', action='store_true', help='Enable the viewer and visualizes the plan')
args = parser.parse_args()
print('Arguments:', args)
connect(use_gui=args.viewer)
robot, names, movable = load_world()
print('Objects:', names)
saver = WorldSaver()
problem = pddlstream_from_problem(robot, movable=movable, teleport=args.teleport)
_, _, _, stream_map, init, goal = problem
print('Init:', init)
print('Goal:', goal)
print('Streams:', str_from_object(set(stream_map)))
with Profiler():
with LockRenderer(lock=not args.enable):
solution = solve(problem, algorithm=args.algorithm, unit_costs=args.unit, success_cost=INF)
saver.restore()
print_solution(solution)
plan, cost, evaluations = solution
if (plan is None) or not has_gui():
disconnect()
return
command = postprocess_plan(plan)
if args.simulate:
wait_for_user('Simulate?')
command.control()
else:
wait_for_user('Execute?')
#command.step()
command.refine(num_steps=10).execute(time_step=0.001)
wait_for_user('Finish?')
disconnect()
def main():
parser = create_parser()
parser.add_argument('-problem', default='problem1', help='The name of the problem to solve')
parser.add_argument('-cfree', action='store_true', help='Disables collisions')
parser.add_argument('-deterministic', action='store_true', help='Uses a deterministic sampler')
parser.add_argument('-optimal', action='store_true', help='Runs in an anytime mode')
parser.add_argument('-t', '--max_time', default=120, type=int, help='The max time')
parser.add_argument('-enable', action='store_true', help='Enables rendering during planning')
parser.add_argument('-teleport', action='store_true', help='Teleports between configurations')
parser.add_argument('-simulate', action='store_true', help='Simulates the system')
parser.add_argument('-viewer', action='store_true', help='Enable the viewer and visualizes the plan')
args = parser.parse_args()
print('Arguments:', args)
problem_fn_from_name = {fn.__name__: fn for fn in PROBLEMS}
if args.problem not in problem_fn_from_name:
raise ValueError(args.problem)
problem_fn = problem_fn_from_name[args.problem]
connect(use_gui=args.viewer)
with HideOutput():
problem = problem_fn()
saver = WorldSaver()
draw_base_limits(problem.limits, color=RED)
pddlstream_problem = pddlstream_from_problem(problem, collisions=not args.cfree, teleport=args.teleport)
stream_info = {
'inverse-kinematics': StreamInfo(),
'plan-base-motion': StreamInfo(overhead=1e1),
}
_, _, _, stream_map, init, goal = pddlstream_problem
print('Init:', init)
print('Goal:', goal)
#print('Streams:', stream_map.keys())
success_cost = 0 if args.optimal else INF
planner = 'ff-astar'
search_sample_ratio = 1
max_planner_time = 10
with Profiler(field='cumtime', num=25): # cumtime | tottime
with LockRenderer(lock=not args.enable):
solution = solve(pddlstream_problem, stream_info=stream_info,
planner=planner, max_planner_time=max_planner_time,
unit_costs=args.unit, success_cost=success_cost,
max_time=args.max_time, verbose=True, debug=False,
unit_efforts=True, effort_weight=1,
search_sample_ratio=search_sample_ratio)
saver.restore()
print_solution(solution)
plan, cost, evaluations = solution
if (plan is None) or not has_gui():
disconnect()
return
# Maybe openrave didn't actually sample any joints...
# http://openrave.org/docs/0.8.2/openravepy/examples.tutorial_iksolutions/
with LockRenderer(lock=not args.enable):
commands = post_process(problem, plan, teleport=args.teleport)
saver.restore()
if args.simulate:
control_commands(commands)
else:
time_step = None if args.teleport else 0.01
apply_commands(BeliefState(problem), commands, time_step)
wait_for_user()
disconnect()
def main():
parser = create_parser(default_algorithm='binding')
parser.add_argument('-cfree',
action='store_true',
help='Disables collisions')
parser.add_argument('-deterministic',
action='store_true',
help='Uses a deterministic sampler')
parser.add_argument('-optimal',
action='store_true',
help='Runs in an anytime mode')
parser.add_argument('-t',
'--max_time',
default=120,
type=int,
help='The max time')
parser.add_argument('-enable',
action='store_true',
help='Enables rendering during planning')
parser.add_argument('-simulate',
action='store_true',
help='Simulates the system')
parser.add_argument('-viewer',
action='store_true',
help='Enable the viewer and visualizes the plan')
args = parser.parse_args()
print('Arguments:', args)
connect(use_gui=args.viewer)
with HideOutput():
problem = problem_fn(collisions=not args.cfree)
saver = WorldSaver()
draw_base_limits(problem.limits, color=RED)
pddlstream_problem = pddlstream_from_problem(problem)
stream_info = {
'test-cfree-conf-pose': StreamInfo(p_success=1e-2),
'test-cfree-traj-pose': StreamInfo(p_success=1e-1),
'compute-motion': StreamInfo(eager=True, p_success=0),
'test-reachable': StreamInfo(eager=True),
'Distance': FunctionInfo(eager=True),
}
_, _, _, stream_map, init, goal = pddlstream_problem
print('Init:', init)
print('Goal:', goal)
success_cost = 0 if args.optimal else INF
planner = 'ff-wastar1'
search_sample_ratio = 0
max_planner_time = 10
with Profiler(field='tottime', num=25): # cumtime | tottime
with LockRenderer(lock=not args.enable):
solution = solve(pddlstream_problem,
algorithm=args.algorithm,
stream_info=stream_info,
planner=planner,
max_planner_time=max_planner_time,
debug=False,
unit_costs=args.unit,
success_cost=success_cost,
max_time=args.max_time,
verbose=True,
unit_efforts=True,
effort_weight=1,
search_sample_ratio=search_sample_ratio)
saver.restore()
print_solution(solution)
plan, cost, evaluations = solution
if (plan is None) or not has_gui():
disconnect()
return
with LockRenderer():
commands = post_process(problem, plan)
saver.restore() # Assumes bodies are ordered the same way
wait_for_user()
if args.simulate:
control_commands(commands)
else:
apply_commands(BeliefState(problem), commands,
time_step=1e-2) # 1e-2 | None
wait_for_user()
disconnect()
def main(teleport=False):
#parser = create_parser()
parser = argparse.ArgumentParser()
parser.add_argument('-algorithm', default='incremental', help='Specifies the algorithm')
parser.add_argument('-cfree', action='store_true', help='Disables collisions')
parser.add_argument('-deterministic', action='store_true', help='Uses a deterministic sampler')
parser.add_argument('-optimal', action='store_true', help='Runs in an anytime mode')
parser.add_argument('-t', '--max_time', default=5*60, type=int, help='The max time')
parser.add_argument('-enable', action='store_true', help='Enables rendering during planning')
parser.add_argument('-viewer', action='store_true', help='Enable the viewer and visualizes the plan')
args = parser.parse_args()
print('Arguments:', args)
connect(use_gui=args.viewer)
with HideOutput():
namo_problem = problem_fn(collisions=not args.cfree)
saver = WorldSaver()
draw_base_limits(namo_problem.limits, color=RED)
pddlstream_problem, edges = pddlstream_from_problem(namo_problem, teleport=teleport)
_, constant_map, _, stream_map, init, goal = pddlstream_problem
print('Constants:', constant_map)
print('Init:', init)
print('Goal:', goal)
stream_info = {
'compute-motion': StreamInfo(eager=True, p_success=0),
'ConfConfCollision': PredicateInfo(p_success=1, overhead=0.1),
'TrajConfCollision': PredicateInfo(p_success=1, overhead=1),
'TrajTrajCollision': PredicateInfo(p_success=1, overhead=10),
'TrajDistance': FunctionInfo(eager=True), # Need to eagerly evaluate otherwise 0 duration (failure)
}
success_cost = 0 if args.optimal else INF
max_planner_time = 10
with Profiler(field='tottime', num=25): # cumtime | tottime
with LockRenderer(lock=not args.enable):
# TODO: solution = solve_incremental(pddlstream_problem
if args.algorithm == 'incremental':
solution = solve_incremental(pddlstream_problem,
max_planner_time=max_planner_time,
success_cost=success_cost, max_time=args.max_time,
start_complexity=INF,
verbose=True, debug=True)
elif args.algorithm == 'focused':
solution = solve_focused(pddlstream_problem, stream_info=stream_info,
max_planner_time=max_planner_time,
success_cost=success_cost, max_time=args.max_time,
max_skeletons=None, bind=True, max_failures=INF,
verbose=True, debug=True)
else:
raise ValueError(args.algorithm)
print_solution(solution)
plan, cost, evaluations = solution
if (plan is None) or not has_gui():
disconnect()
return
saver.restore()
draw_edges(edges)
state = BeliefState(namo_problem)
wait_for_user('Begin?')
#time_step = None if teleport else 0.01
#with VideoSaver('video.mp4'):
display_plan(namo_problem, state, plan)
wait_for_user('Finish?')
disconnect()
def main(partial=False, defer=False, verbose=True):
parser = create_parser()
parser.add_argument('-enable',
action='store_true',
help='Enables rendering during planning')
parser.add_argument('-teleport',
action='store_true',
help='Teleports between configurations')
parser.add_argument('-simulate',
action='store_true',
help='Simulates the system')
parser.add_argument('-viewer',
action='store_true',
help='Enable the viewer and visualizes the plan')
args = parser.parse_args()
print('Arguments:', args)
connect(use_gui=args.viewer)
problem_fn = cooking_problem
# holding_problem | stacking_problem | cleaning_problem | cooking_problem
# cleaning_button_problem | cooking_button_problem
with HideOutput():
problem = problem_fn()
#state_id = save_state()
saver = WorldSaver()
#dump_world()
pddlstream_problem = pddlstream_from_problem(problem,
teleport=args.teleport)
stream_info = {
# 'test-cfree-pose-pose': StreamInfo(p_success=1e-3, verbose=verbose),
# 'test-cfree-approach-pose': StreamInfo(p_success=1e-2, verbose=verbose),
# 'test-cfree-traj-pose': StreamInfo(p_success=1e-1, verbose=verbose),
'MoveCost': FunctionInfo(opt_move_cost_fn),
}
stream_info.update({
'sample-pose':
StreamInfo(PartialInputs('?r')),
'inverse-kinematics':
StreamInfo(PartialInputs('?p')),
'plan-base-motion':
StreamInfo(PartialInputs('?q1 ?q2'),
defer_fn=defer_shared if defer else never_defer),
} if partial else {
'sample-pose': StreamInfo(from_fn(opt_pose_fn)),
'inverse-kinematics': StreamInfo(from_fn(opt_ik_fn)),
'plan-base-motion': StreamInfo(from_fn(opt_motion_fn)),
})
_, _, _, stream_map, init, goal = pddlstream_problem
print('Init:', init)
print('Goal:', goal)
print('Streams:', str_from_object(set(stream_map)))
print(SEPARATOR)
with Profiler():
with LockRenderer(lock=not args.enable):
solution = solve(pddlstream_problem,
algorithm=args.algorithm,
unit_costs=args.unit,
stream_info=stream_info,
success_cost=INF,
verbose=True,
debug=False)
saver.restore()
print_solution(solution)
plan, cost, evaluations = solution
if (plan is None) or not has_gui():
disconnect()
return
print(SEPARATOR)
with LockRenderer(lock=not args.enable):
commands = post_process(problem, plan)
problem.remove_gripper()
saver.restore()
#restore_state(state_id)
saver.restore()
wait_if_gui('Execute?')
if args.simulate:
control_commands(commands)
else:
apply_commands(State(), commands, time_step=0.01)
wait_if_gui('Finish?')
disconnect()
def main(verbose=True):
# TODO: could work just on postprocessing
# TODO: try the other reachability database
# TODO: option to only consider costs during local optimization
parser = create_parser()
parser.add_argument('-problem',
default='packed',
help='The name of the problem to solve')
parser.add_argument('-n',
'--number',
default=5,
type=int,
help='The number of objects')
parser.add_argument('-cfree',
action='store_true',
help='Disables collisions')
parser.add_argument('-deterministic',
action='store_true',
help='Uses a deterministic sampler')
parser.add_argument('-optimal',
action='store_true',
help='Runs in an anytime mode')
parser.add_argument('-t',
'--max_time',
default=120,
type=int,
help='The max time')
parser.add_argument('-teleport',
action='store_true',
help='Teleports between configurations')
parser.add_argument('-enable',
action='store_true',
help='Enables rendering during planning')
parser.add_argument('-simulate',
action='store_true',
help='Simulates the system')
parser.add_argument('-viewer',
action='store_true',
help='Enable the viewer and visualizes the plan')
args = parser.parse_args()
print('Arguments:', args)
problem_fn_from_name = {fn.__name__: fn for fn in PROBLEMS}
if args.problem not in problem_fn_from_name:
raise ValueError(args.problem)
problem_fn = problem_fn_from_name[args.problem]
connect(use_gui=args.viewer)
with HideOutput():
problem = problem_fn(num=args.number)
draw_base_limits(problem.base_limits, color=(1, 0, 0))
saver = WorldSaver()
#handles = []
#for link in get_group_joints(problem.robot, 'left_arm'):
# handles.append(draw_link_name(problem.robot, link))
#wait_for_user()
pddlstream_problem = pddlstream_from_problem(problem,
collisions=not args.cfree,
teleport=args.teleport)
stream_info = {
'inverse-kinematics':
StreamInfo(),
'plan-base-motion':
StreamInfo(overhead=1e1),
'test-cfree-pose-pose':
StreamInfo(p_success=1e-3, verbose=verbose),
'test-cfree-approach-pose':
StreamInfo(p_success=1e-2, verbose=verbose),
'test-cfree-traj-pose':
StreamInfo(p_success=1e-1,
verbose=verbose), # TODO: apply to arm and base trajs
#'test-cfree-traj-grasp-pose': StreamInfo(verbose=verbose),
'Distance':
FunctionInfo(p_success=0.99, opt_fn=lambda q1, q2: BASE_CONSTANT),
#'MoveCost': FunctionInfo(lambda t: BASE_CONSTANT),
}
#stream_info = {}
_, _, _, stream_map, init, goal = pddlstream_problem
print('Init:', init)
print('Goal:', goal)
print('Streams:', str_from_object(set(stream_map)))
success_cost = 0 if args.optimal else INF
planner = 'ff-astar' if args.optimal else 'ff-wastar3'
search_sample_ratio = 2
max_planner_time = 10
# effort_weight = 0 if args.optimal else 1
effort_weight = 1e-3 if args.optimal else 1
with Profiler(field='tottime', num=25): # cumtime | tottime
with LockRenderer(lock=not args.enable):
solution = solve(pddlstream_problem,
algorithm=args.algorithm,
stream_info=stream_info,
planner=planner,
max_planner_time=max_planner_time,
unit_costs=args.unit,
success_cost=success_cost,
max_time=args.max_time,
verbose=True,
debug=False,
unit_efforts=True,
effort_weight=effort_weight,
search_sample_ratio=search_sample_ratio)
saver.restore()
cost_over_time = [(s.cost, s.time) for s in SOLUTIONS]
for i, (cost, runtime) in enumerate(cost_over_time):
print('Plan: {} | Cost: {:.3f} | Time: {:.3f}'.format(
i, cost, runtime))
#print(SOLUTIONS)
print_solution(solution)
plan, cost, evaluations = solution
if (plan is None) or not has_gui():
disconnect()
return
with LockRenderer(lock=not args.enable):
commands = post_process(problem, plan, teleport=args.teleport)
saver.restore()
draw_base_limits(problem.base_limits, color=(1, 0, 0))
wait_for_user()
if args.simulate:
control_commands(commands)
else:
time_step = None if args.teleport else 0.01
apply_commands(State(), commands, time_step)
wait_for_user()
disconnect()
def main():
parser = create_parser()
parser.add_argument('-problem',
default='rovers1',
help='The name of the problem to solve')
parser.add_argument('-cfree',
action='store_true',
help='Disables collisions')
parser.add_argument('-deterministic',
action='store_true',
help='Uses a deterministic sampler')
parser.add_argument('-optimal',
action='store_true',
help='Runs in an anytime mode')
parser.add_argument('-t',
'--max_time',
default=120,
type=int,
help='The max time')
parser.add_argument('-enable',
action='store_true',
help='Enables rendering during planning')
parser.add_argument('-teleport',
action='store_true',
help='Teleports between configurations')
parser.add_argument('-simulate',
action='store_true',
help='Simulates the system')
parser.add_argument('-viewer',
action='store_true',
help='Enable the viewer and visualizes the plan')
args = parser.parse_args()
print('Arguments:', args)
problem_fn_from_name = {fn.__name__: fn for fn in PROBLEMS}
if args.problem not in problem_fn_from_name:
raise ValueError(args.problem)
problem_fn = problem_fn_from_name[args.problem]
connect(use_gui=args.viewer)
with HideOutput():
rovers_problem = problem_fn()
saver = WorldSaver()
draw_base_limits(rovers_problem.limits, color=RED)
pddlstream_problem = pddlstream_from_problem(rovers_problem,
collisions=not args.cfree,
teleport=args.teleport,
holonomic=False,
reversible=True,
use_aabb=True)
stream_info = {
'test-cfree-ray-conf': StreamInfo(),
'test-reachable': StreamInfo(p_success=1e-1),
'obj-inv-visible': StreamInfo(),
'com-inv-visible': StreamInfo(),
'sample-above': StreamInfo(),
'sample-motion': StreamInfo(overhead=10),
}
_, _, _, stream_map, init, goal = pddlstream_problem
print('Init:', init)
print('Goal:', goal)
#print('Streams:', stream_map.keys())
success_cost = 0 if args.optimal else INF
planner = 'ff-wastar3'
search_sample_ratio = 2
max_planner_time = 10
# TODO: need to accelerate samples here because of the failed test reachable
with Profiler(field='tottime', num=25):
with LockRenderer(lock=not args.enable):
# TODO: option to only consider costs during local optimization
solution = solve(pddlstream_problem,
algorithm=args.algorithm,
stream_info=stream_info,
planner=planner,
max_planner_time=max_planner_time,
debug=False,
unit_costs=args.unit,
success_cost=success_cost,
max_time=args.max_time,
verbose=True,
unit_efforts=True,
effort_weight=1,
search_sample_ratio=search_sample_ratio)
for body in get_bodies():
if body not in saver.bodies:
remove_body(body)
saver.restore()
print_solution(solution)
plan, cost, evaluations = solution
if (plan is None) or not has_gui():
disconnect()
return
# Maybe OpenRAVE didn't actually sample any joints...
# http://openrave.org/docs/0.8.2/openravepy/examples.tutorial_iksolutions/
with LockRenderer():
commands = post_process(rovers_problem, plan)
saver.restore()
wait_for_user('Begin?')
if args.simulate:
control_commands(commands)
else:
time_step = None if args.teleport else 0.01
apply_commands(BeliefState(rovers_problem), commands, time_step)
wait_for_user('Finish?')
disconnect()