def move_look_trajectory(task, trajectory, max_tilt=np.pi / 6): # max_tilt=INF): # TODO: implement a minimum distance instead of max_tilt # TODO: pr2 movement restrictions #base_path = [pose.to_base_conf() for pose in trajectory.path] base_path = trajectory.path if not base_path: return trajectory obstacles = get_fixed_bodies(task) # TODO: movable objects robot = base_path[0].body target_path = get_target_path(trajectory) waypoints = [] index = 0 with BodySaver(robot): #current_conf = base_values_from_pose(get_pose(robot)) for i, conf in enumerate(base_path): # TODO: just do two loops? conf.assign() while index < len(target_path): if i < index: # Don't look at past or current conf target_point = target_path[index] head_conf = inverse_visibility( robot, target_point) # TODO: this is slightly slow #print(index, target_point, head_conf) if (head_conf is not None) and (head_conf[1] < max_tilt): break index += 1 else: head_conf = get_group_conf(robot, 'head') set_group_conf(robot, 'head', head_conf) #print(i, index, conf.values, head_conf) #, get_pose(robot)) waypoints.append(np.concatenate([conf.values, head_conf])) joints = tuple(base_path[0].joints) + tuple(get_group_joints( robot, 'head')) #joints = get_group_joints(robot, 'base') + get_group_joints(robot, 'head') #set_pose(robot, unit_pose()) #set_group_conf(robot, 'base', current_conf) path = plan_waypoints_joint_motion(robot, joints, waypoints, obstacles=obstacles, self_collisions=SELF_COLLISIONS) return create_trajectory(robot, joints, path)
def gen(o, p): if o in task.rooms: #bq = Pose(robot, unit_pose()) #bq = state.poses[robot] bq = Conf(robot, base_joints, np.zeros(len(base_joints))) #hq = Conf(robot, head_joints, np.zeros(len(head_joints))) #ht = create_trajectory(robot, head_joints, plan_pause_scan_path(robot, tilt=tilt)) waypoints = plan_scan_path(task.robot, tilt=tilt) set_group_conf(robot, 'head', waypoints[0]) path = plan_waypoints_joint_motion(robot, head_joints, waypoints[1:], obstacles=None, self_collisions=False) ht = create_trajectory(robot, head_joints, path) yield bq, ht.path[0], ht else: for bq, hq in vis_gen(o, p): ht = Trajectory([hq]) yield bq, ht.path[0], ht
def inspect_trajectory(trajectory): if not trajectory.path: return robot = trajectory.path[0].body # TODO: minimum distance of some sort (to prevent from looking at the bottom) # TODO: custom lower limit as well head_waypoints = [] for target_point in get_target_path(trajectory): head_conf = inverse_visibility(robot, target_point) # TODO: could also draw the sequence of inspected points as the head moves if head_conf is None: continue head_waypoints.append(head_conf) head_joints = get_group_joints(robot, 'head') #return create_trajectory(robot, head_joints, head_waypoints) head_path = plan_waypoints_joint_motion(robot, head_joints, head_waypoints, obstacles=None, self_collisions=False) assert (head_path is not None) return create_trajectory(robot, head_joints, head_path)
def fn(o, p, bq): set_pose(o, p.value) # p.assign() bq.assign() if o in task.rooms: waypoints = plan_scan_path(task.robot, tilt=ROOM_SCAN_TILT) set_group_conf(robot, 'head', waypoints[0]) path = plan_waypoints_joint_motion(robot, head_joints, waypoints[1:], obstacles=None, self_collisions=False) if path is None: return None ht = create_trajectory(robot, head_joints, path) hq = ht.path[0] else: target_point = point_from_pose(p.value) head_conf = inverse_visibility(robot, target_point) if head_conf is None: # TODO: test if visible return None hq = Conf(robot, head_joints, head_conf) ht = Trajectory([hq]) return (hq, ht)
def gen_fn(index, pose, grasp): body = brick_from_index[index].body #world_pose = get_link_pose(robot, tool_link) #draw_pose(world_pose, length=0.04) #set_pose(body, multiply(world_pose, grasp.attach)) #draw_pose(multiply(pose.value, invert(grasp.attach)), length=0.04) #wait_for_interrupt() set_pose(body, pose.value) for _ in range(max_attempts): set_joint_positions(robot, movable_joints, sample_fn()) # Random seed attach_pose = multiply(pose.value, invert(grasp.attach)) attach_conf = inverse_kinematics(robot, tool_link, attach_pose) if attach_conf is None: continue approach_pose = multiply(attach_pose, ([0, 0, -0.1], unit_quat())) #approach_pose = multiply(pose.value, invert(grasp.approach)) approach_conf = inverse_kinematics(robot, tool_link, approach_pose) if approach_conf is None: continue # TODO: retreat path = plan_waypoints_joint_motion( robot, movable_joints, [approach_conf, attach_conf], obstacles=obstacle_from_name.values(), self_collisions=True, disabled_collisions=disabled_collisions) if path is None: continue #path = [approach_conf, attach_conf] attachment = Attachment(robot, tool_link, grasp.attach, body) traj = MotionTrajectory(robot, movable_joints, path, attachments=[attachment]) yield approach_conf, traj break