class GiskardTestWrapper(object):
def __init__(self, config_file):
with open(get_ros_pkg_path(u'giskardpy') + u'/config/' +
config_file) as f:
config = yaml.load(f)
rospy.set_param('~', config)
rospy.set_param('~path_to_data_folder', u'tmp_data/')
rospy.set_param('~enable_gui', False)
rospy.set_param('~plugins/PlotTrajectory/enabled', True)
self.sub_result = rospy.Subscriber('~command/result',
MoveActionResult,
self.cb,
queue_size=100)
self.cancel_goal = rospy.Publisher('~command/cancel',
GoalID,
queue_size=100)
self.tree = grow_tree()
self.loop_once()
# rospy.sleep(1)
self.wrapper = GiskardWrapper(node_name=u'tests')
self.results = Queue(100)
self.default_root = self.get_robot().get_root()
self.map = u'map'
self.simple_base_pose_pub = rospy.Publisher('/move_base_simple/goal',
PoseStamped,
queue_size=10)
self.set_base = rospy.ServiceProxy('/base_simulator/set_joint_states',
SetJointState)
self.tick_rate = 10
def create_publisher(topic):
p = rospy.Publisher(topic, JointState, queue_size=10)
rospy.sleep(.2)
return p
self.joint_state_publisher = KeyDefaultDict(create_publisher)
# rospy.sleep(1)
def wait_for_synced(self):
sleeper = rospy.Rate(self.tick_rate)
self.loop_once()
# while self.tree.tip().name != u'has goal':
# self.loop_once()
# sleeper.sleep()
# self.loop_once()
# while self.tree.tip().name != u'has goal':
# self.loop_once()
# sleeper.sleep()
def get_robot(self):
"""
:rtype: Robot
"""
return self.get_god_map().get_data(robot)
def get_god_map(self):
"""
:rtype: giskardpy.god_map.GodMap
"""
return Blackboard().god_map
def cb(self, msg):
"""
:type msg: MoveActionResult
"""
self.results.put(msg.result)
def loop_once(self):
self.tree.tick()
def get_controlled_joint_names(self):
"""
:rtype: dict
"""
return self.get_robot().controlled_joints
def get_controllable_links(self):
return self.get_robot().get_controlled_links()
def get_current_joint_state(self):
"""
:rtype: JointState
"""
return rospy.wait_for_message('joint_states', JointState)
def tear_down(self):
rospy.sleep(1)
logging.loginfo(u'stopping plugins')
def set_object_joint_state(self, object_name, joint_state):
self.wrapper.set_object_joint_state(object_name, joint_state)
rospy.sleep(0.5)
self.wait_for_synced()
current_js = self.get_world().get_object(object_name).joint_state
for joint_name, state in joint_state.items():
np.testing.assert_almost_equal(current_js[joint_name].position,
state, 2)
def set_kitchen_js(self, joint_state, object_name=u'kitchen'):
self.set_object_joint_state(object_name, joint_state)
#
# JOINT GOAL STUFF #################################################################################################
#
def compare_joint_state(self, current_js, goal_js, decimal=2):
"""
:type current_js: dict
:type goal_js: dict
:type decimal: int
"""
joint_names = set(current_js.keys()).intersection(set(goal_js.keys()))
for joint_name in joint_names:
goal = goal_js[joint_name]
current = current_js[joint_name]
if self.get_robot().is_joint_continuous(joint_name):
np.testing.assert_almost_equal(shortest_angular_distance(
goal, current),
0,
decimal=decimal)
else:
np.testing.assert_almost_equal(
current,
goal,
decimal,
err_msg='{} at {} insteand of {}'.format(
joint_name, current, goal))
def set_joint_goal(self, js, weight=None):
"""
:rtype js: dict
"""
self.wrapper.set_joint_goal(js, weight=weight)
def check_joint_state(self, expected, decimal=2):
current_joint_state = to_joint_state_position_dict(
self.get_current_joint_state())
self.compare_joint_state(current_joint_state,
expected,
decimal=decimal)
def send_and_check_joint_goal(self,
goal,
weight=None,
decimal=2,
expected_error_codes=None):
"""
:type goal: dict
"""
self.set_joint_goal(goal, weight=weight)
self.send_and_check_goal(expected_error_codes=expected_error_codes)
if expected_error_codes == [MoveResult.SUCCESS]:
self.check_joint_state(goal, decimal=decimal)
#
# CART GOAL STUFF ##################################################################################################
#
def teleport_base(self, goal_pose):
goal_pose = transform_pose(self.default_root, goal_pose)
js = {
u'odom_x_joint':
goal_pose.pose.position.x,
u'odom_y_joint':
goal_pose.pose.position.y,
u'odom_z_joint':
rotation_from_matrix(
quaternion_matrix([
goal_pose.pose.orientation.x, goal_pose.pose.orientation.y,
goal_pose.pose.orientation.z, goal_pose.pose.orientation.w
]))[0]
}
goal = SetJointStateRequest()
goal.state = position_dict_to_joint_states(js)
self.set_base.call(goal)
self.loop_once()
rospy.sleep(0.5)
self.loop_once()
def keep_position(self, tip, root=None):
if root is None:
root = self.default_root
goal = PoseStamped()
goal.header.frame_id = tip
goal.pose.orientation.w = 1
self.set_cart_goal(goal, tip, root)
def keep_orientation(self, tip, root=None):
goal = PoseStamped()
goal.header.frame_id = tip
goal.pose.orientation.w = 1
self.set_rotation_goal(goal, tip, root)
def align_planes(self,
tip_link,
tip_normal,
root_link=None,
root_normal=None,
weight=None):
self.wrapper.align_planes(tip_link, tip_normal, root_link, root_normal,
weight)
def set_rotation_goal(self,
goal_pose,
tip_link,
root_link=None,
max_velocity=None):
if not root_link:
root_link = self.default_root
self.wrapper.set_rotation_goal(root_link,
tip_link,
goal_pose,
max_velocity=max_velocity)
def set_translation_goal(self,
goal_pose,
tip_link,
root_link=None,
max_velocity=None):
if not root_link:
root_link = self.default_root
self.wrapper.set_translation_goal(root_link,
tip_link,
goal_pose,
max_velocity=max_velocity)
def set_cart_goal(self,
goal_pose,
tip_link,
root_link=None,
weight=None,
linear_velocity=None,
angular_velocity=None):
if not root_link:
root_link = self.default_root
if weight is not None:
self.wrapper.set_cart_goal(root_link,
tip_link,
goal_pose,
weight=weight,
max_linear_velocity=linear_velocity,
max_angular_velocity=angular_velocity)
else:
self.wrapper.set_cart_goal(root_link,
tip_link,
goal_pose,
max_linear_velocity=linear_velocity,
max_angular_velocity=angular_velocity)
def set_and_check_cart_goal(self,
goal_pose,
tip_link,
root_link=None,
weight=None,
linear_velocity=None,
angular_velocity=None,
expected_error_codes=None):
goal_pose_in_map = transform_pose(u'map', goal_pose)
self.set_cart_goal(goal_pose,
tip_link,
root_link,
weight,
linear_velocity=linear_velocity,
angular_velocity=angular_velocity)
self.loop_once()
self.send_and_check_goal(expected_error_codes)
self.loop_once()
if expected_error_codes is None:
self.check_cart_goal(tip_link, goal_pose_in_map)
def check_cart_goal(self, tip_link, goal_pose):
goal_in_base = transform_pose(u'map', goal_pose)
current_pose = lookup_pose(u'map', tip_link)
np.testing.assert_array_almost_equal(
msg_to_list(goal_in_base.pose.position),
msg_to_list(current_pose.pose.position),
decimal=2)
try:
np.testing.assert_array_almost_equal(
msg_to_list(goal_in_base.pose.orientation),
msg_to_list(current_pose.pose.orientation),
decimal=2)
except AssertionError:
np.testing.assert_array_almost_equal(
msg_to_list(goal_in_base.pose.orientation),
-np.array(msg_to_list(current_pose.pose.orientation)),
decimal=2)
#
# GENERAL GOAL STUFF ###############################################################################################
#
def interrupt(self):
self.cancel_goal.publish(GoalID())
def check_reachability(self, expected_error_codes=None):
self.send_and_check_goal(
expected_error_codes=expected_error_codes,
goal_type=MoveGoal.PLAN_AND_CHECK_REACHABILITY)
def get_as(self):
return Blackboard().get(u'~command')
def send_goal(self,
goal=None,
goal_type=MoveGoal.PLAN_AND_EXECUTE,
wait=True):
"""
:rtype: MoveResult
"""
if goal is None:
goal = MoveActionGoal()
goal.goal = self.wrapper._get_goal()
goal.goal.type = goal_type
i = 0
self.loop_once()
t1 = Thread(
target=self.get_as()._as.action_server.internal_goal_callback,
args=(goal, ))
self.loop_once()
t1.start()
sleeper = rospy.Rate(self.tick_rate)
while self.results.empty():
self.loop_once()
sleeper.sleep()
i += 1
t1.join()
self.loop_once()
result = self.results.get()
return result
def send_goal_and_dont_wait(self,
goal=None,
goal_type=MoveGoal.PLAN_AND_EXECUTE,
stop_after=20):
if goal is None:
goal = MoveActionGoal()
goal.goal = self.wrapper._get_goal()
goal.goal.type = goal_type
i = 0
self.loop_once()
t1 = Thread(
target=self.get_as()._as.action_server.internal_goal_callback,
args=(goal, ))
self.loop_once()
t1.start()
sleeper = rospy.Rate(self.tick_rate)
while self.results.empty():
self.loop_once()
sleeper.sleep()
i += 1
if i > stop_after:
self.interrupt()
t1.join()
self.loop_once()
result = self.results.get()
return result
def send_and_check_goal(self,
expected_error_codes=None,
goal_type=MoveGoal.PLAN_AND_EXECUTE,
goal=None):
r = self.send_goal(goal=goal, goal_type=goal_type)
for i in range(len(r.error_codes)):
error_code = r.error_codes[i]
error_message = r.error_messages[i]
if expected_error_codes is None:
expected_error_code = MoveResult.SUCCESS
else:
expected_error_code = expected_error_codes[i]
assert error_code == expected_error_code, \
u'in goal {}; got: {}, expected: {} | error_massage: {}'.format(i, move_result_error_code(error_code),
move_result_error_code(
expected_error_code),
error_message)
return r.trajectory
def add_waypoint(self):
self.wrapper.add_cmd()
def add_json_goal(self, constraint_type, **kwargs):
self.wrapper.set_json_goal(constraint_type, **kwargs)
def get_result_trajectory_position(self):
trajectory = self.get_god_map().unsafe_get_data(identifier.trajectory)
trajectory2 = []
for t, p in trajectory._points.items():
trajectory2.append(
{joint_name: js.position
for joint_name, js in p.items()})
return trajectory2
def get_result_trajectory_velocity(self):
trajectory = self.get_god_map().get_data(identifier.trajectory)
trajectory2 = []
for t, p in trajectory._points.items():
trajectory2.append(
{joint_name: js.velocity
for joint_name, js in p.items()})
return trajectory2
def are_joint_limits_violated(self):
controllable_joints = self.get_robot().get_movable_joints()
trajectory_pos = self.get_result_trajectory_position()
trajectory_vel = self.get_result_trajectory_velocity()
for joint in controllable_joints:
joint_limits = self.get_robot().get_joint_limits(joint)
vel_limit = self.get_robot().get_joint_velocity_limit(joint)
trajectory_pos_joint = [p[joint] for p in trajectory_pos]
trajectory_vel_joint = [p[joint] for p in trajectory_vel]
if any(
round(p, 7) < joint_limits[0]
and round(p, 7) > joint_limits[1]
for p in trajectory_pos_joint):
return True
if any(
round(p, 7) < vel_limit and round(p, 7) > vel_limit
for p in trajectory_vel_joint):
return True
return False
#
# BULLET WORLD #####################################################################################################
#
def get_world(self):
"""
:rtype: PyBulletWorld
"""
return self.get_god_map().get_data(world)
def clear_world(self):
assert self.wrapper.clear_world(
).error_codes == UpdateWorldResponse.SUCCESS
assert len(self.get_world().get_object_names()) == 0
assert len(self.wrapper.get_object_names().object_names) == 0
# assert len(self.get_robot().get_attached_objects()) == 0
# assert self.get_world().has_object(u'plane')
def remove_object(self,
name,
expected_response=UpdateWorldResponse.SUCCESS):
r = self.wrapper.remove_object(name)
assert r.error_codes == expected_response, \
u'got: {}, expected: {}'.format(update_world_error_code(r.error_codes),
update_world_error_code(expected_response))
assert not self.get_world().has_object(name)
assert not name in self.wrapper.get_object_names().object_names
def detach_object(self,
name,
expected_response=UpdateWorldResponse.SUCCESS):
if expected_response == UpdateWorldResponse.SUCCESS:
p = self.get_robot().get_fk_pose(self.get_robot().get_root(), name)
p = transform_pose(u'map', p)
assert name in self.wrapper.get_attached_objects().object_names, \
'there is no attached object named {}'.format(name)
r = self.wrapper.detach_object(name)
assert r.error_codes == expected_response, \
u'got: {}, expected: {}'.format(update_world_error_code(r.error_codes),
update_world_error_code(expected_response))
if expected_response == UpdateWorldResponse.SUCCESS:
assert self.get_world().has_object(name)
assert not name in self.wrapper.get_attached_objects(
).object_names, 'the object was not detached'
compare_poses(self.get_world().get_object(name).base_pose,
p.pose,
decimal=2)
def add_box(self,
name=u'box',
size=(1, 1, 1),
pose=None,
expected_response=UpdateWorldResponse.SUCCESS):
r = self.wrapper.add_box(name, size, pose=pose)
assert r.error_codes == expected_response, \
u'got: {}, expected: {}'.format(update_world_error_code(r.error_codes),
update_world_error_code(expected_response))
p = transform_pose(u'map', pose)
o_p = self.get_world().get_object(name).base_pose
assert self.get_world().has_object(name)
compare_poses(p.pose, o_p)
assert name in self.wrapper.get_object_names().object_names
compare_poses(o_p, self.wrapper.get_object_info(name).pose.pose)
def add_sphere(self, name=u'sphere', size=1, pose=None):
r = self.wrapper.add_sphere(name=name, size=size, pose=pose)
assert r.error_codes == UpdateWorldResponse.SUCCESS, \
u'got: {}, expected: {}'.format(update_world_error_code(r.error_codes),
update_world_error_code(UpdateWorldResponse.SUCCESS))
assert self.get_world().has_object(name)
assert name in self.wrapper.get_object_names().object_names
o_p = self.get_world().get_object(name).base_pose
compare_poses(o_p, self.wrapper.get_object_info(name).pose.pose)
def add_cylinder(self, name=u'cylinder', size=[1, 1], pose=None):
r = self.wrapper.add_cylinder(name=name,
height=size[0],
radius=size[1],
pose=pose)
assert r.error_codes == UpdateWorldResponse.SUCCESS, \
u'got: {}, expected: {}'.format(update_world_error_code(r.error_codes),
update_world_error_code(UpdateWorldResponse.SUCCESS))
assert self.get_world().has_object(name)
assert name in self.wrapper.get_object_names().object_names
def add_mesh(self,
name=u'cylinder',
path=u'',
pose=None,
expected_error=UpdateWorldResponse.SUCCESS):
r = self.wrapper.add_mesh(name=name, mesh=path, pose=pose)
assert r.error_codes == expected_error, \
u'got: {}, expected: {}'.format(update_world_error_code(r.error_codes),
update_world_error_code(expected_error))
if expected_error == UpdateWorldResponse.SUCCESS:
assert self.get_world().has_object(name)
assert name in self.wrapper.get_object_names().object_names
o_p = self.get_world().get_object(name).base_pose
compare_poses(o_p, self.wrapper.get_object_info(name).pose.pose)
else:
assert not self.get_world().has_object(name)
assert name not in self.wrapper.get_object_names().object_names
def add_urdf(self, name, urdf, pose, js_topic=u'', set_js_topic=None):
r = self.wrapper.add_urdf(name,
urdf,
pose,
js_topic,
set_js_topic=set_js_topic)
assert r.error_codes == UpdateWorldResponse.SUCCESS, \
u'got: {}, expected: {}'.format(update_world_error_code(r.error_codes),
update_world_error_code(UpdateWorldResponse.SUCCESS))
assert self.get_world().has_object(name)
assert name in self.wrapper.get_object_names().object_names
def add_CollisionShape(self,
name,
path,
pose,
js_topic=u'',
set_js_topic=None):
r = self.wrapper.add_urdf(name,
urdf,
pose,
js_topic,
set_js_topic=set_js_topic)
assert r.error_codes == UpdateWorldResponse.SUCCESS, \
u'got: {}, expected: {}'.format(update_world_error_code(r.error_codes),
update_world_error_code(UpdateWorldResponse.SUCCESS))
assert self.get_world().has_object(name)
assert name in self.wrapper.get_object_names().object_names
def allow_all_collisions(self):
self.wrapper.allow_all_collisions()
def avoid_all_collisions(self, distance=0.5):
self.wrapper.avoid_all_collisions(distance)
self.loop_once()
def allow_self_collision(self):
self.wrapper.allow_self_collision()
def avoid_self_collision(self):
self.wrapper.avoid_self_collision()
def add_collision_entries(self, collisions_entries):
self.wrapper.set_collision_entries(collisions_entries)
def allow_collision(self, robot_links, body_b, link_bs):
ces = []
ces.append(
CollisionEntry(type=CollisionEntry.ALLOW_COLLISION,
robot_links=robot_links,
body_b=body_b,
link_bs=link_bs))
self.add_collision_entries(ces)
def avoid_collision(self, robot_links, body_b, link_bs, min_dist):
ces = []
ces.append(
CollisionEntry(type=CollisionEntry.AVOID_COLLISION,
robot_links=robot_links,
body_b=body_b,
link_bs=link_bs,
min_dist=min_dist))
self.add_collision_entries(ces)
def attach_box(self,
name=u'box',
size=None,
frame_id=None,
position=None,
orientation=None,
pose=None,
expected_response=UpdateWorldResponse.SUCCESS):
scm = self.get_robot().get_self_collision_matrix()
if pose is None:
expected_pose = PoseStamped()
expected_pose.header.frame_id = frame_id
expected_pose.pose.position = Point(*position)
if orientation:
expected_pose.pose.orientation = Quaternion(*orientation)
else:
expected_pose.pose.orientation = Quaternion(0, 0, 0, 1)
else:
expected_pose = deepcopy(pose)
r = self.wrapper.attach_box(name, size, frame_id, position,
orientation, pose)
assert r.error_codes == expected_response, \
u'got: {}, expected: {}'.format(update_world_error_code(r.error_codes),
update_world_error_code(expected_response))
if expected_response == UpdateWorldResponse.SUCCESS:
self.wait_for_synced()
assert name in self.get_controllable_links()
assert not self.get_world().has_object(name)
assert not name in self.wrapper.get_object_names().object_names
assert name in self.wrapper.get_attached_objects(
).object_names, 'object {} was not attached'
assert scm.difference(
self.get_robot().get_self_collision_matrix()) == set()
assert len(scm) < len(self.get_robot().get_self_collision_matrix())
compare_poses(expected_pose.pose, lookup_pose(frame_id, name).pose)
self.loop_once()
def attach_cylinder(self,
name=u'cylinder',
height=1,
radius=1,
frame_id=None,
position=None,
orientation=None,
expected_response=UpdateWorldResponse.SUCCESS):
scm = self.get_robot().get_self_collision_matrix()
expected_pose = PoseStamped()
expected_pose.header.frame_id = frame_id
expected_pose.pose.position = Point(*position)
if orientation:
expected_pose.pose.orientation = Quaternion(*orientation)
else:
expected_pose.pose.orientation = Quaternion(0, 0, 0, 1)
r = self.wrapper.attach_cylinder(name, height, radius, frame_id,
position, orientation)
assert r.error_codes == expected_response, \
u'got: {}, expected: {}'.format(update_world_error_code(r.error_codes),
update_world_error_code(expected_response))
if expected_response == UpdateWorldResponse.SUCCESS:
self.wait_for_synced()
assert name in self.get_controllable_links()
assert not self.get_world().has_object(name)
assert not name in self.wrapper.get_object_names().object_names
assert name in self.wrapper.get_attached_objects().object_names
assert scm.difference(
self.get_robot().get_self_collision_matrix()) == set()
assert len(scm) < len(self.get_robot().get_self_collision_matrix())
compare_poses(expected_pose.pose, lookup_pose(frame_id, name).pose)
self.loop_once()
def attach_existing(self,
name=u'box',
frame_id=None,
expected_response=UpdateWorldResponse.SUCCESS):
scm = self.get_robot().get_self_collision_matrix()
r = self.wrapper.attach_object(name, frame_id)
assert r.error_codes == expected_response, \
u'got: {}, expected: {}'.format(update_world_error_code(r.error_codes),
update_world_error_code(expected_response))
self.wait_for_synced()
assert name in self.get_controllable_links()
assert not self.get_world().has_object(name)
assert not name in self.wrapper.get_object_names().object_names
assert name in self.wrapper.get_attached_objects().object_names
assert scm.difference(
self.get_robot().get_self_collision_matrix()) == set()
assert len(scm) < len(self.get_robot().get_self_collision_matrix())
self.loop_once()
def get_external_collisions(self, link, distance_threshold):
"""
:param distance_threshold:
:rtype: list
"""
collision_goals = [
CollisionEntry(type=CollisionEntry.AVOID_ALL_COLLISIONS,
min_dist=distance_threshold)
]
collision_matrix = self.get_world(
).collision_goals_to_collision_matrix(collision_goals,
defaultdict(lambda: 0.3))
collisions = self.get_world().check_collisions(collision_matrix)
controlled_parent_joint = self.get_robot().get_controlled_parent_joint(
link)
controlled_parent_link = self.get_robot().get_child_link_of_joint(
controlled_parent_joint)
collision_list = collisions.get_external_collisions(
controlled_parent_link)
for key, self_collisions in collisions.self_collisions.items():
if controlled_parent_link in key:
collision_list.update(self_collisions)
return collision_list
def check_cpi_geq(self, links, distance_threshold):
for link in links:
collisions = self.get_external_collisions(link, distance_threshold)
assert collisions[0].get_contact_distance() >= distance_threshold, \
u'distance for {}: {} >= {}'.format(link,
collisions[0].get_contact_distance(),
distance_threshold)
def check_cpi_leq(self, links, distance_threshold):
for link in links:
collisions = self.get_external_collisions(link, distance_threshold)
assert collisions[0].get_contact_distance() <= distance_threshold, \
u'distance for {}: {} <= {}'.format(link,
collisions[0].get_contact_distance(),
distance_threshold)
def move_base(self, goal_pose):
"""
:type goal_pose: PoseStamped
"""
self.simple_base_pose_pub.publish(goal_pose)
rospy.sleep(.07)
self.wait_for_synced()
current_pose = self.get_robot().get_base_pose()
goal_pose = transform_pose(u'map', goal_pose)
compare_poses(goal_pose.pose, current_pose.pose, decimal=1)
def reset_base(self):
p = PoseStamped()
p.header.frame_id = self.map
p.pose.orientation.w = 1
self.teleport_base(p)
class PlaceServer:
_feedback = PlaceFeedback()
_result = PlaceResult()
_root = u'odom'
def __init__(self, name):
self._action_name = name
self._as = actionlib.SimpleActionServer(self._action_name, PlaceAction, execute_cb=self.execute_cb,
auto_start=False)
self._giskard_wrapper = GiskardWrapper()
self._gripper = Gripper(apply_force_action_server=u'/hsrb/gripper_controller/apply_force',
follow_joint_trajectory_server=u'/hsrb/gripper_controller/follow_joint_trajectory')
self._manipulator = Manipulator(mode_rotation=self.get_mode_rotation())
self._as.start()
if tfwrapper.tfBuffer is None:
tfwrapper.init()
rospy.loginfo("{} is ready and waiting for orders.".format(self._action_name))
def get_mode_rotation(self):
mode_rotation = {}
front_rotation = rospy.get_param(u'/manipulation/base_gripper_rotation/front', default=None)
top_rotation = rospy.get_param(u'/manipulation/base_gripper_rotation/top', default=None)
if front_rotation:
mode_rotation[PlaceGoal.FRONT] = front_rotation
if top_rotation:
mode_rotation[PlaceGoal.TOP] = top_rotation
return mode_rotation
def execute_cb(self, goal):
# uncomment to disable collision avoidance
# self._manipulator.set_collision(None)
rospy.loginfo("Placing: {}".format(goal))
# Set initial result value.
success = True
self._result.error_code = self._result.FAILED
if goal.object_frame_id not in self._giskard_wrapper.get_attached_objects().object_names:
rospy.logwarn("object not attached to gripper: {}".format(goal.object_frame_id))
# get current robot_pose
robot_pose = tfwrapper.lookup_pose('map', 'base_footprint')
success &= self._manipulator.move_to_goal(root_link=self._root,
tip_link=u'hand_gripper_tool_frame',
goal_pose=goal.goal_pose,
robot_pose=robot_pose,
mode=goal.place_mode,
step=0.1)
if success:
self._gripper.set_gripper_joint_position(1.2)
if goal.object_frame_id in self._giskard_wrapper.get_attached_objects().object_names:
self._giskard_wrapper.detach_object(goal.object_frame_id)
self._gripper.publish_object_in_gripper(goal.object_frame_id, goal.goal_pose, ObjectInGripper.PLACED)
collision_whitelist = []
if goal.object_frame_id in self._giskard_wrapper.get_object_names().object_names:
collision_whitelist.append(goal.object_frame_id)
else:
rospy.logwarn("unknown object: {}".format(goal.object_frame_id))
robot_pose.header.stamp = rospy.Time.now() # Might not be needed but is cleaner this way
success &= self._manipulator.move_to_goal(root_link=self._root,
tip_link=u'base_footprint',
goal_pose=robot_pose,
collision_whitelist=collision_whitelist)
success &= self._manipulator.take_robot_pose(rospy.get_param(u'/manipulation/robot_poses/neutral'))
if success:
self._result.error_code = self._result.SUCCESS
self._as.set_succeeded(self._result)
class GiskardTestWrapper(object):
def __init__(self, config_file):
with open(get_ros_pkg_path(u'giskardpy') + u'/config/' +
config_file) as f:
config = yaml.load(f)
rospy.set_param(u'~', config)
rospy.set_param(u'~path_to_data_folder', u'tmp_data/')
rospy.set_param(u'~enable_gui', False)
self.sub_result = rospy.Subscriber(u'/giskardpy/command/result',
MoveActionResult,
self.cb,
queue_size=100)
self.tree = grow_tree()
self.loop_once()
# rospy.sleep(1)
self.wrapper = GiskardWrapper(ns=u'tests')
self.results = Queue(100)
self.default_root = self.get_robot().get_root()
self.map = u'map'
self.simple_base_pose_pub = rospy.Publisher(u'/move_base_simple/goal',
PoseStamped,
queue_size=10)
self.set_base = rospy.ServiceProxy(u'/base_simulator/set_joint_states',
SetJointState)
self.tick_rate = 10
def create_publisher(topic):
p = rospy.Publisher(topic, JointState, queue_size=10)
rospy.sleep(.2)
return p
self.joint_state_publisher = KeyDefaultDict(create_publisher)
# rospy.sleep(1)
def wait_for_synced(self):
sleeper = rospy.Rate(self.tick_rate)
self.loop_once()
# while self.tree.tip().name != u'has goal':
# self.loop_once()
# sleeper.sleep()
# self.loop_once()
# while self.tree.tip().name != u'has goal':
# self.loop_once()
# sleeper.sleep()
def get_robot(self):
"""
:rtype: Robot
"""
return self.get_god_map().safe_get_data(robot)
def get_god_map(self):
"""
:rtype: giskardpy.god_map.GodMap
"""
return Blackboard().god_map
def cb(self, msg):
"""
:type msg: MoveActionResult
"""
self.results.put(msg.result)
def loop_once(self):
self.tree.tick()
def get_controlled_joint_names(self):
"""
:rtype: dict
"""
return self.get_robot().controlled_joints
def get_controllable_links(self):
return self.get_robot().get_controlled_links()
def get_current_joint_state(self):
"""
:rtype: JointState
"""
return rospy.wait_for_message(u'joint_states', JointState)
def tear_down(self):
rospy.sleep(1)
logging.loginfo(u'stopping plugins')
def set_object_joint_state(self, object_name, joint_state, topic=None):
if topic is None:
self.wrapper.set_object_joint_state(object_name, joint_state)
else:
self.joint_state_publisher[topic].publish(
dict_to_joint_states(joint_state))
rospy.sleep(.5)
self.wait_for_synced()
current_js = self.get_world().get_object(object_name).joint_state
for joint_name, state in joint_state.items():
np.testing.assert_almost_equal(current_js[joint_name].position,
state, 2)
def set_kitchen_js(self, joint_state, object_name=u'kitchen'):
self.set_object_joint_state(object_name,
joint_state,
topic=u'/kitchen/cram_joint_states')
#
# JOINT GOAL STUFF #################################################################################################
#
def compare_joint_state(self, current_js, goal_js, decimal=2):
"""
:type current_js: dict
:type goal_js: dict
:type decimal: int
"""
joint_names = set(current_js.keys()).intersection(set(goal_js.keys()))
for joint_name in joint_names:
goal = goal_js[joint_name]
current = current_js[joint_name]
if self.get_robot().is_joint_continuous(joint_name):
np.testing.assert_almost_equal(shortest_angular_distance(
goal, current),
0,
decimal=decimal)
else:
np.testing.assert_almost_equal(
current,
goal,
decimal,
err_msg=u'{} at {} insteand of {}'.format(
joint_name, current, goal))
def set_joint_goal(self, js):
"""
:rtype js: dict
"""
self.wrapper.set_joint_goal(js)
def check_joint_state(self, expected, decimal=2):
current_joint_state = to_joint_state_dict2(
self.get_current_joint_state())
self.compare_joint_state(current_joint_state,
expected,
decimal=decimal)
def send_and_check_joint_goal(self, goal, decimal=2):
"""
:type goal: dict
"""
self.set_joint_goal(goal)
self.send_and_check_goal()
self.check_joint_state(goal, decimal=decimal)
#
# CART GOAL STUFF ##################################################################################################
#
def teleport_base(self, goal_pose):
goal_pose = transform_pose(self.default_root, goal_pose)
js = {
u'odom_x_joint':
goal_pose.pose.position.x,
u'odom_y_joint':
goal_pose.pose.position.y,
u'odom_z_joint':
rotation_from_matrix(
quaternion_matrix([
goal_pose.pose.orientation.x, goal_pose.pose.orientation.y,
goal_pose.pose.orientation.z, goal_pose.pose.orientation.w
]))[0]
}
goal = SetJointStateRequest()
goal.state = dict_to_joint_states(js)
self.set_base.call(goal)
def keep_position(self, tip, root=None):
if root is None:
root = self.default_root
goal = PoseStamped()
goal.header.frame_id = tip
goal.pose.orientation.w = 1
self.set_cart_goal(goal, tip, root)
def keep_orientation(self, tip, root=None):
goal = PoseStamped()
goal.header.frame_id = tip
goal.pose.orientation.w = 1
self.set_rotation_goal(goal, tip, root)
def align_planes(self, tip, tip_normal, root=None, root_normal=None):
self.wrapper.align_planes(tip, tip_normal, root, root_normal)
def set_rotation_goal(self, goal_pose, tip, root=None):
if not root:
root = self.default_root
self.wrapper.set_rotation_goal(root, tip, goal_pose)
def set_translation_goal(self, goal_pose, tip, root=None):
if not root:
root = self.default_root
self.wrapper.set_translation_goal(root, tip, goal_pose)
def set_cart_goal(self, goal_pose, tip, root=None):
if not root:
root = self.default_root
self.wrapper.set_cart_goal(root, tip, goal_pose)
def set_and_check_cart_goal(self,
goal_pose,
tip,
root=None,
expected_error_code=MoveResult.SUCCESS):
goal_pose_in_map = transform_pose(u'map', goal_pose)
self.set_cart_goal(goal_pose, tip, root)
self.loop_once()
self.send_and_check_goal(expected_error_code)
self.loop_once()
self.check_cart_goal(tip, goal_pose_in_map)
def check_cart_goal(self, tip, goal_pose):
goal_in_base = transform_pose(u'map', goal_pose)
current_pose = lookup_pose(u'map', tip)
np.testing.assert_array_almost_equal(
msg_to_list(goal_in_base.pose.position),
msg_to_list(current_pose.pose.position),
decimal=2)
try:
np.testing.assert_array_almost_equal(
msg_to_list(goal_in_base.pose.orientation),
msg_to_list(current_pose.pose.orientation),
decimal=2)
except AssertionError:
np.testing.assert_array_almost_equal(
msg_to_list(goal_in_base.pose.orientation),
-np.array(msg_to_list(current_pose.pose.orientation)),
decimal=2)
#
# GENERAL GOAL STUFF ###############################################################################################
#
def get_as(self):
return Blackboard().get(u'giskardpy/command')
def send_goal(self, goal=None, execute=True):
"""
:rtype: MoveResult
"""
if goal is None:
goal = MoveActionGoal()
goal.goal = self.wrapper._get_goal()
if execute:
goal.goal.type = MoveGoal.PLAN_AND_EXECUTE
else:
goal.goal.type = MoveGoal.PLAN_ONLY
i = 0
self.loop_once()
t1 = Thread(
target=self.get_as()._as.action_server.internal_goal_callback,
args=(goal, ))
self.loop_once()
t1.start()
sleeper = rospy.Rate(self.tick_rate)
while self.results.empty():
self.loop_once()
sleeper.sleep()
i += 1
t1.join()
self.loop_once()
result = self.results.get()
return result
def send_and_check_goal(self,
expected_error_code=MoveResult.SUCCESS,
execute=True):
r = self.send_goal(execute=execute)
assert r.error_code == expected_error_code, \
u'got: {}, expected: {}'.format(move_result_error_code(r.error_code),
move_result_error_code(expected_error_code))
def add_waypoint(self):
self.wrapper.add_cmd()
def add_json_goal(self, constraint_type, **kwargs):
self.wrapper.set_json_goal(constraint_type, **kwargs)
def get_trajectory_msg(self):
trajectory = self.get_god_map().get_data(identifier.trajectory)
trajectory2 = []
for t, p in trajectory._points.items():
trajectory2.append(
{joint_name: js.position
for joint_name, js in p.items()})
return trajectory2
#
# BULLET WORLD #####################################################################################################
#
def get_world(self):
"""
:rtype: PyBulletWorld
"""
return self.get_god_map().safe_get_data(world)
def clear_world(self):
assert self.wrapper.clear_world(
).error_codes == UpdateWorldResponse.SUCCESS
assert len(self.get_world().get_object_names()) == 0
# assert len(self.get_robot().get_attached_objects()) == 0
# assert self.get_world().has_object(u'plane')
def remove_object(self,
name,
expected_response=UpdateWorldResponse.SUCCESS):
r = self.wrapper.remove_object(name)
assert r.error_codes == expected_response, \
u'got: {}, expected: {}'.format(update_world_error_code(r.error_codes),
update_world_error_code(expected_response))
assert not self.get_world().has_object(name)
def detach_object(self,
name,
expected_response=UpdateWorldResponse.SUCCESS):
if expected_response == UpdateWorldResponse.SUCCESS:
p = self.get_robot().get_fk_pose(self.get_robot().get_root(), name)
p = transform_pose(u'map', p)
r = self.wrapper.detach_object(name)
assert r.error_codes == expected_response, \
u'got: {}, expected: {}'.format(update_world_error_code(r.error_codes),
update_world_error_code(expected_response))
if expected_response == UpdateWorldResponse.SUCCESS:
assert self.get_world().has_object(name)
compare_poses(self.get_world().get_object(name).base_pose,
p.pose,
decimal=2)
def add_box(self,
name=u'box',
size=(1, 1, 1),
pose=None,
expected_response=UpdateWorldResponse.SUCCESS):
r = self.wrapper.add_box(name, size, pose=pose)
assert r.error_codes == expected_response, \
u'got: {}, expected: {}'.format(update_world_error_code(r.error_codes),
update_world_error_code(expected_response))
p = transform_pose(u'map', pose)
o_p = self.get_world().get_object(name).base_pose
assert self.get_world().has_object(name)
compare_poses(p.pose, o_p)
def add_sphere(self, name=u'sphere', size=1, pose=None):
r = self.wrapper.add_sphere(name=name, size=size, pose=pose)
assert r.error_codes == UpdateWorldResponse.SUCCESS, \
u'got: {}, expected: {}'.format(update_world_error_code(r.error_codes),
update_world_error_code(UpdateWorldResponse.SUCCESS))
assert self.get_world().has_object(name)
def add_cylinder(self, name=u'cylinder', size=[1, 1], pose=None):
r = self.wrapper.add_cylinder(name=name, size=size, pose=pose)
assert r.error_codes == UpdateWorldResponse.SUCCESS, \
u'got: {}, expected: {}'.format(update_world_error_code(r.error_codes),
update_world_error_code(UpdateWorldResponse.SUCCESS))
assert self.get_world().has_object(name)
def add_urdf(self, name, urdf, pose, js_topic):
r = self.wrapper.add_urdf(name, urdf, pose, js_topic)
assert r.error_codes == UpdateWorldResponse.SUCCESS, \
u'got: {}, expected: {}'.format(update_world_error_code(r.error_codes),
update_world_error_code(UpdateWorldResponse.SUCCESS))
assert self.get_world().has_object(name)
def allow_all_collisions(self):
self.wrapper.allow_all_collisions()
def avoid_all_collisions(self, distance=0.5):
self.wrapper.avoid_all_collisions(distance)
self.loop_once()
def enable_self_collision(self):
pass
def allow_self_collision(self):
self.wrapper.allow_self_collision()
def add_collision_entries(self, collisions_entries):
self.wrapper.set_collision_entries(collisions_entries)
def allow_collision(self, robot_links, body_b, link_bs):
ces = []
ces.append(
CollisionEntry(type=CollisionEntry.ALLOW_COLLISION,
robot_links=robot_links,
body_b=body_b,
link_bs=link_bs))
self.add_collision_entries(ces)
def avoid_collision(self, robot_links, body_b, link_bs, min_dist):
ces = []
ces.append(
CollisionEntry(type=CollisionEntry.AVOID_COLLISION,
robot_links=robot_links,
body_b=body_b,
link_bs=link_bs,
min_dist=min_dist))
self.add_collision_entries(ces)
def attach_box(self,
name=u'box',
size=None,
frame_id=None,
position=None,
orientation=None,
expected_response=UpdateWorldResponse.SUCCESS):
scm = self.get_robot().get_self_collision_matrix()
expected_pose = PoseStamped()
expected_pose.header.frame_id = frame_id
expected_pose.pose.position = Point(*position)
if orientation:
expected_pose.pose.orientation = Quaternion(*orientation)
else:
expected_pose.pose.orientation = Quaternion(0, 0, 0, 1)
r = self.wrapper.attach_box(name, size, frame_id, position,
orientation)
assert r.error_codes == expected_response, \
u'got: {}, expected: {}'.format(update_world_error_code(r.error_codes),
update_world_error_code(expected_response))
if expected_response == UpdateWorldResponse.SUCCESS:
self.wait_for_synced()
assert name in self.get_controllable_links()
assert not self.get_world().has_object(name)
assert scm.difference(
self.get_robot().get_self_collision_matrix()) == set()
assert len(scm) < len(self.get_robot().get_self_collision_matrix())
compare_poses(expected_pose.pose, lookup_pose(frame_id, name).pose)
self.loop_once()
def attach_cylinder(self,
name=u'cylinder',
height=1,
radius=1,
frame_id=None,
position=None,
orientation=None,
expected_response=UpdateWorldResponse.SUCCESS):
scm = self.get_robot().get_self_collision_matrix()
expected_pose = PoseStamped()
expected_pose.header.frame_id = frame_id
expected_pose.pose.position = Point(*position)
if orientation:
expected_pose.pose.orientation = Quaternion(*orientation)
else:
expected_pose.pose.orientation = Quaternion(0, 0, 0, 1)
r = self.wrapper.attach_cylinder(name, height, radius, frame_id,
position, orientation)
assert r.error_codes == expected_response, \
u'got: {}, expected: {}'.format(update_world_error_code(r.error_codes),
update_world_error_code(expected_response))
if expected_response == UpdateWorldResponse.SUCCESS:
self.wait_for_synced()
assert name in self.get_controllable_links()
assert not self.get_world().has_object(name)
assert scm.difference(
self.get_robot().get_self_collision_matrix()) == set()
assert len(scm) < len(self.get_robot().get_self_collision_matrix())
compare_poses(expected_pose.pose, lookup_pose(frame_id, name).pose)
self.loop_once()
def attach_existing(self,
name=u'box',
frame_id=None,
expected_response=UpdateWorldResponse.SUCCESS):
scm = self.get_robot().get_self_collision_matrix()
r = self.wrapper.attach_object(name, frame_id)
assert r.error_codes == expected_response, \
u'got: {}, expected: {}'.format(update_world_error_code(r.error_codes),
update_world_error_code(expected_response))
self.wait_for_synced()
assert name in self.get_controllable_links()
assert not self.get_world().has_object(name)
assert scm.difference(
self.get_robot().get_self_collision_matrix()) == set()
assert len(scm) < len(self.get_robot().get_self_collision_matrix())
self.loop_once()
def get_external_collisions(self, link, distance_threshold):
"""
:param distance_threshold:
:rtype: list
"""
collision_goals = [
CollisionEntry(type=CollisionEntry.AVOID_ALL_COLLISIONS,
min_dist=distance_threshold)
]
collision_matrix = self.get_world(
).collision_goals_to_collision_matrix(
collision_goals,
self.get_god_map().safe_get_data(identifier.distance_thresholds))
collisions = self.get_world().check_collisions(collision_matrix)
collisions = self.get_world().transform_contact_info(collisions)
collision_list = collisions.external_collision[
self.get_robot().get_movable_parent_joint(link)]
for key, self_collisions in collisions.self_collisions.items():
if link in key:
collision_list.update(self_collisions)
return collision_list
def check_cpi_geq(self, links, distance_threshold):
for link in links:
collisions = self.get_external_collisions(link, distance_threshold)
assert collisions[0].contact_distance >= distance_threshold
def check_cpi_leq(self, links, distance_threshold):
for link in links:
collisions = self.get_external_collisions(link, distance_threshold)
assert collisions[0].contact_distance <= distance_threshold
def move_base(self, goal_pose):
"""
:type goal_pose: PoseStamped
"""
self.simple_base_pose_pub.publish(goal_pose)
rospy.sleep(.07)
self.wait_for_synced()
current_pose = self.get_robot().get_base_pose()
goal_pose = transform_pose(u'map', goal_pose)
compare_poses(goal_pose.pose, current_pose.pose, decimal=1)
def reset_base(self):
p = PoseStamped()
p.header.frame_id = self.map
p.pose.orientation.w = 1
self.teleport_base(p)
class MakePlanServer:
def __init__(self, name):
self._action_name = name
self.dummy_object_ = u'dummy_plan_object'
self.gripper_frame_ = u'hand_palm_link'
self.root_frame_ = u'odom'
self._as = actionlib.SimpleActionServer(self._action_name, MakePlanAction, execute_cb=self.execute_cb,
auto_start=False)
self._giskard_wrapper = GiskardWrapper()
self.mode_rotation_ = self.get_mode_rotation()
self._as.start()
rospy.loginfo("{} is ready and waiting for orders.".format(self._action_name))
def get_mode_rotation(self):
mode_rotation = {}
front_rotation = rospy.get_param(u'/manipulation/base_gripper_rotation/front', default=None)
top_rotation = rospy.get_param(u'/manipulation/base_gripper_rotation/top', default=None)
if front_rotation:
mode_rotation[MakePlanGoal.FRONT] = front_rotation
if top_rotation:
mode_rotation[MakePlanGoal.TOP] = top_rotation
return mode_rotation
def execute_cb(self, goal):
rospy.loginfo("Making plan: {}".format(goal))
self._result = MakePlanResult()
self._result.error_code = self._result.FAILED
# TODO move robot in start pose currently replaced with actual robot pose
robot_pose = tfwrapper.lookup_pose('map', 'base_footprint')
# Prepare object
if goal.action_mode == goal.PLACE:
if goal.object_frame_id not in self._giskard_wrapper.get_attached_objects().object_names:
rospy.loginfo("object not attached to gripper: {}. Creating dummy object".format(goal.object_frame_id))
if self.dummy_object_ in self._giskard_wrapper.get_object_names().object_names:
self._giskard_wrapper.remove_object(self.dummy_object_)
self._giskard_wrapper.add_box(self.dummy_object_,
[goal.object_size.x, goal.object_size.y, goal.object_size.z],
self.gripper_frame_)
self._giskard_wrapper.attach_object(self.dummy_object_, self.gripper_frame_)
elif goal.action_mode == goal.GRASP:
if goal.object_frame_id in self._giskard_wrapper.get_object_names().object_names:
self._giskard_wrapper.allow_collision(body_b=goal.object_frame_id)
else:
rospy.logerr("Unknown action_mode: {}".format(goal.action_mode))
self._as.set_succeeded(self._result)
return
if goal.gripper_mode in [goal.FRONT, goal.TOP]:
goal.goal_pose.pose.orientation = Quaternion(
*quaternion_multiply(to_tf_quaternion(robot_pose.pose.orientation),
self.mode_rotation_[goal.gripper_mode]))
self._giskard_wrapper.set_cart_goal(self.root_frame_, self.gripper_frame_, goal.goal_pose)
self._giskard_wrapper.plan()
result = self._giskard_wrapper.get_result()
# Clean up dummy object
if self.dummy_object_ in self._giskard_wrapper.get_attached_objects().object_names:
self._giskard_wrapper.detach_object(self.dummy_object_)
self._giskard_wrapper.remove_object(self.dummy_object_)
# Clean up collission excemption for goal_object
self._giskard_wrapper.avoid_all_collisions()
if result.SUCCESS in result.error_codes:
self._result.error_code = self._result.SUCCESS
self._as.set_succeeded(self._result)
#! /usr/bin/env python
import rospy
from giskardpy.python_interface import GiskardWrapper
from giskardpy import tfwrapper
rospy.init_node('add_static_giskard')
giskard_wrapper = GiskardWrapper()
_urdf = rospy.get_param('hsrb_lab', False)
kitchen_frame = rospy.get_param('~environment_frame', 'iai_kitchen/world')
while not _urdf:
rospy.sleep(5)
_urdf = rospy.get_param('hsrb_lab', False)
giskard_wrapper.detach_object('gripper_dummy')
giskard_wrapper.remove_object('gripper_dummy')
giskard_wrapper.remove_object('lab')
p = tfwrapper.lookup_pose('map', kitchen_frame)
#giskard_wrapper.attach_box(name='gripper_dummy', size=[0.05, 0.1, 0.1], frame_id="hand_palm_link",
# position=[0.05, 0, 0.05], orientation=[0, 0, 0, 1])
giskard_wrapper.add_urdf(name='lab', urdf=_urdf, js_topic='/kitchen/joint_states', pose=p)