def setUp(self): self.env, self.robot = herbpy.initialize(sim=True) self.fuze = prpy.rave.add_object(self.env, 'fuze_bottle', 'objects/fuze_bottle.kinbody.xml') self.robot.right_arm.SetActive() self.fuze_pose = numpy.eye(4) self.fuze_pose[0:3, 3] = [0.8, -0.3, 0.4] self.fuze.SetTransform(self.fuze_pose) self.fuze.Enable(True)
def setup_env(isReal, attach_viewer=True): env, robot = herbpy.initialize(sim=not isReal, attach_viewer=attach_viewer) if isReal: robot.left_arm.SetVelocityLimits(np.ones(7)*1.2, 1.2) table = add_table(env, robot) bin = add_bin(env) return env, robot, table, bin
def main(): #import IPython #IPython.embed() env, robot = herbpy.initialize(sim=True, attach_viewer='interactivemarker') planning_env = HerbEnv(env, robot) obj_list = planning_env.obj_list import IPython IPython.embed() plan = Planner(env, robot, planning_env) plan.Plan(obj_list) time.sleep(10000)
def main(): sim = True env, robot = herbpy.initialize(sim=sim, segway_sim=True) #robot.right_arm.SetActive() robot.head.SetStiffness(1) robot.head.MoveTo([0, -0.4]) robot.SetActiveManipulator(robot.right_arm) env.SetViewer('qtcoin') env.GetViewer().SetName('HPN Viewer') env.Add(robot) kinbody_env = HerbEnv(env, robot, sim) import IPython IPython.embed() plan = Planner(env, robot, kinbody_env) plan.Plan(kinbody_env.obj_list)
def main(): sim = True env, robot = herbpy.initialize(sim=sim,segway_sim=True) #robot.right_arm.SetActive() robot.head.SetStiffness(1) robot.head.MoveTo([0,-0.4]) robot.SetActiveManipulator(robot.right_arm) env.SetViewer('qtcoin') env.GetViewer().SetName('HPN Viewer') env.Add(robot) kinbody_env = HerbEnv(env,robot,sim) import IPython IPython.embed() plan = Planner(env,robot,kinbody_env) plan.Plan(kinbody_env.obj_list)
def run_benchmark(body, engine, testfile=None, self_collision=False, envfile=None, random=50000, extent=2.0, viewer=None, outfile=None ): # Load the environment if body == 'herb': env, robot = herbpy.initialize(sim=True, attach_viewer=viewer) else: env = openravepy.Environment() if envfile: env.Load(envfile) # Set the collision checker cc = openravepy.RaveCreateCollisionChecker(env, engine) cc.SetCollisionOptions(0) if cc is None: raise Exception('Invalid collision engine. Failing.') env.SetCollisionChecker(cc) # Verify the kinbody is in the environment body = env.GetKinBody(body) if body is None: raise Exception('No body with name %s in environment. Failing.' % body) # Load the openrave module try: module = openravepy.RaveCreateModule(env, 'collisioncheckingbenchmark') except openravepy.openrave_exception: raise Exception('Unable to load CollisionCheckingBenchmark module.' ' Check your OPENRAVE_PLUGINS environment variable.') # Generate the parameters params = {} params['body'] = str(body.GetName()) params['random'] = random if outfile is not None: params['outfile'] = outfile params['extent'] = extent if self_collision: params['self'] = True if testfile: params['datafile'] = testfile with env: result = module.SendCommand("Run " + str(params))
num_non_adjacent_links = len(non_adjacent_links) actual_num_link_pairs = num_adjacent_links + num_non_adjacent_links print "robot.GetAdjacentLinks() = ", robot.GetAdjacentLinks() print "robot.GetNonAdjacentLinks() = ", robot.GetNonAdjacentLinks() if expected_num_link_pairs == actual_num_link_pairs: print ("\nLink pairs are correct\n") else: print ("\nERROR: some link pairs are missing\n") # Initialize OpenRAVE robot of type herbpy.herbrobot.HERBRobot: # env, robot = herbpy.initialize(sim=True, attach_viewer=True) # env, robot = herbpy.initialize(sim=True, attach_viewer='qtcoin') env, robot = herbpy.initialize(sim=True, attach_viewer="rviz") # env, robot = herbpy.initialize(sim=True, attach_viewer='interactivemarker') # Load the fridge (trimesh only) current_dir = os.path.dirname(os.path.abspath(__file__)) # fridge_file = os.path.join(current_dir, 'prkitchen_refrigerator.robot.xml') fridge_file = os.path.join(current_dir, "fridge_trimesh.robot.xml") env.Load(fridge_file) fridge = env.GetKinBody("refrigerator") CheckAdjacentLinks(fridge) # Delete the fridge env.Remove(env.GetKinBody("refrigerator"))
else: angle_measurement = abs(max_measurement[iaxis] - min_measurement[iaxis]) if angle_measurement - angle_actual > math.pi: angle_measurement = angle_measurement - 2 * math.pi elif angle_measurement - angle_actual < -math.pi: angle_measurement = angle_measurement + 2 * math.pi return angle_actual, angle_measurement if __name__ == '__main__': sim = False namespace = '/left/owd/' output_path = 'transmission_ratios.yaml' env, robot = herbpy.initialize(sim=sim, segway_sim=True, head_sim=True, right_arm_sim=True, right_hand_sim=True, attach_viewer='interactivemarker') robot.planner = prpy.planning.SnapPlanner() # TODO: Hack to work around a race condition in or_interactivemarker. import time time.sleep(0.1) manipulator = robot.left_arm robot.SetActiveDOFs(manipulator.GetArmIndices()) # Pad the joint limits to avoid hitting the floor and head. min_limit, max_limit = robot.GetDOFLimits() arm_indices = manipulator.GetArmIndices() min_limit[arm_indices[1]] = -0.5 max_limit[arm_indices[1]] = 0.5 max_limit[arm_indices[3]] = 1.5
import herbpy import numpy import unittest env, robot = herbpy.initialize(sim=True) class BarrettHandTest(unittest.TestCase): def setUp(self): self._env, self._robot = env, robot self._wam = robot.right_arm self._hand = self._wam.hand self._indices = self._wam.GetChildDOFIndices() self._num_dofs = len(self._indices) def test_GetIndices_ReturnsIndices(self): indices = self._wam.GetChildDOFIndices() numpy.testing.assert_array_equal( sorted(self._hand.GetIndices()), sorted(indices)) def test_GetDOFValues_SetsValues(self): expected_values = numpy.array([0.1, 0.2, 0.3, 0.4]) self._robot.SetDOFValues(expected_values, self._hand.GetIndices()) numpy.testing.assert_array_almost_equal( self._hand.GetDOFValues(), expected_values) def test_SetDOFValues_SetsValues(self): expected_values = numpy.array([ 0.1, 0.2, 0.3, 0.4 ]) self._hand.SetDOFValues(expected_values) numpy.testing.assert_array_almost_equal( self._robot.GetDOFValues(self._hand.GetIndices()), expected_values)
#!/usr/bin/env python import herbpy import numpy if __name__ == '__main__': env, robot = herbpy.initialize(sim=False) env.SetViewer('interactivemarker') keep_going = True while keep_going: print "\n\nWelcome to the pose control:\n \ Press 0 to reset to relaxed home.\n \ Press 1 to wave.\n \ Press 2 to say something.\n \ Press 3 for the Rock On pose.\n \ Press 4 for the Right Arm Hug pose.\n \ Press 5 for the Huzzah pose.\n \ Press 6 for the Samba pose.\n \ Press 9 to quit.\n" user_input = int(raw_input("Gesture? ")) if user_input == 9: print 'Goodbye!\n' keep_going = False elif user_input == 1: print 'Waving!\n' robot.right_arm.SetActive() robot.Wave() elif user_input == 0:
#!/usr/bin/env python import numpy import logging import herbpy import humanpy if __name__ == "__main__": logger = logging.getLogger("test_humherb") logger.setLevel(logging.INFO) sim = True env, herb = herbpy.initialize(attach_viewer=True, sim=sim) with env: _, human = humanpy.initialize(sim=sim, env=env) humanLocation = numpy.array( [[0.0, 0.0, -1.0, 1.9], [-1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.85], [0.0, 0.0, 0.0, 1.0]] # -1.2 # -0.5 ) human.SetTransform(humanLocation) human.right_arm.SetActive() table = env.ReadKinBodyXMLFile("objects/table.kinbody.xml") table_pose = numpy.array( [[0.0, 0.0, 1.0, 1.1], [1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 0.0, 1.0]] ) table.SetTransform(table_pose) table.SetName("table") env.AddKinBody(table) table_aabb = table.ComputeAABB()
[ 3.1670137672513565, -1.5896855774682224, -0.030490730254705722, 1.5286675450710463, -0.032386115821109854, -0.03605547869739324, -0.026511110707008654 ], [ 5.147064052327087, -1.3622957134787639, -0.46951207447023835, 1.4621965585328196, -0.6525084419130015, 0.9042586427293137, -1.00526432576227 ], [ 4.121337486391367, 0.5703433599319374, -2.2175569328355724, 2.049783564999927, -0.2955432490571725, -0.646366247533136, -1.4040613050409545 ], [ 3.102831025390782, -0.04296665515610201, 0.1361467570187895, 0.045580105054784076, -3.0213214848284657, 0.0714728073293458, -0.24661498332101073 ] ] for i,jpos in enumerate(jpos_list): robot.SetActiveDOFValues(jpos, openravepy.KinBody.CheckLimitsAction.Nothing) robot.SetActiveDOFVelocities(numpy.zeros(7)) jtor = robot.ComputeInverseDynamics([]) print('jpos[{}] gravtorques: {}'.format(i, ' '.join(['{:7.3f}'.format(x) for x in jtor[robot.GetActiveDOFIndices()]]))) if __name__ == "__main__": openravepy.RaveInitialize(True) openravepy.misc.InitOpenRAVELogging() # herbpy_args = {'sim':args.sim, # 'attach_viewer':args.viewer, # 'robot_xml':args.robot_xml, # 'env_path':args.env_xml, # 'segway_sim':args.segway_sim} # if args.sim and not args.segway_sim: # herbpy_args['segway_sim'] = args.sim env, robot = herbpy.initialize(sim=True, segway_sim=True) iD()
#!/usr/bin/env python PKG = 'herbpy' import roslib; roslib.load_manifest(PKG) import numpy, unittest import herbpy env, robot = herbpy.initialize(sim=True) class WamTest(unittest.TestCase): def setUp(self): self._env, self._robot = env, robot self._wam = robot.right_arm self._indices = self._wam.GetArmIndices() self._num_dofs = len(self._indices) def test_SetStiffness_DoesNotThrow(self): self._wam.SetStiffness(0.0) self._wam.SetStiffness(0.5) self._wam.SetStiffness(1.0) def test_SetStiffness_InvalidStiffnessThrows(self): self.assertRaises(Exception, self._wam.SetStiffness, (-0.2,)) self.assertRaises(Exception, self._wam.SetStiffness, ( 1.2,)) def test_Servo_DoesNotThrow(self): self._wam.Servo(0.1 * numpy.ones(self._num_dofs)) def test_Servo_IncorrectSizeThrows(self): velocity_small = 0.1 * numpy.ones(self._num_dofs - 1) velocity_large = 0.1 * numpy.ones(self._num_dofs + 1) self.assertRaises(Exception, self._wam.Servo, (velocity_small,))
if angle_measurement - angle_actual > math.pi: angle_measurement = angle_measurement - 2 * math.pi elif angle_measurement - angle_actual < -math.pi: angle_measurement = angle_measurement + 2 * math.pi return angle_actual, angle_measurement if __name__ == '__main__': sim = False namespace = '/left/owd/' output_path = 'transmission_ratios.yaml' env, robot = herbpy.initialize(sim=sim, segway_sim=True, head_sim=True, right_arm_sim=True, right_hand_sim=True, attach_viewer='interactivemarker') robot.planner = prpy.planning.SnapPlanner() # TODO: Hack to work around a race condition in or_interactivemarker. import time time.sleep(0.1) manipulator = robot.left_arm robot.SetActiveDOFs(manipulator.GetArmIndices()) # Pad the joint limits to avoid hitting the floor and head. min_limit, max_limit = robot.GetDOFLimits() arm_indices = manipulator.GetArmIndices() min_limit[arm_indices[1]] = -0.5
#!/usr/bin/env python import herbpy import numpy if __name__ == '__main__': env, robot = herbpy.initialize() keep_going = True while keep_going: print "\n\nWelcome to the gesture control:\n \ Press W to wave.\n \ Press S to say something.\n \ Press Y to nod 'yes'.\n \ Press N to nod 'no'.\n \ Press H to high five.\n \ Press P to point at an object.\n \ Press S to present an object.\n \ Press R to reset the robot.\n \ Press Q to quit.\n" user_input = raw_input("Gesture? ") if user_input == 'Q': print 'Goodbye!\n' keep_going = False elif user_input == 'W': print 'Waving!\n' robot.Wave() elif user_input == 'Y': print 'Nodding yes!\n' robot.Nod(word='yes')
path=directory, first_match_only=True) if len(objects_path) == 0: print 'Can\'t find directory {}/{}'.format(package_name, directory) sys.exit() else: print objects_path # for me this is: #'/home/USERNAME/catkin_workspaces/herb_ws/src/pr-ordata/data/objects' objects_path = objects_path[0] # =========================== # ENVIRONMENT SETUP # =========================== env, robot = herbpy.initialize(sim=True, attach_viewer='rviz') # add a table to the environment table_file = os.path.join(objects_path, 'table.kinbody.xml') table = env.ReadKinBodyXMLFile(table_file) if table == None: print 'Failed to load table kinbody' sys.exit() env.AddKinBody(table) table_pose = numpy.array([[1., 0., 0., 2], [0., 0., -1., 2], [0., 1., 0., 0.0], [0., 0., 0., 1.]]) table.SetTransform(table_pose) # add a fuze bottle on top of the table fuze_path = os.path.join(objects_path, 'fuze_bottle.kinbody.xml') fuze = env.ReadKinBodyXMLFile(fuze_path)
from catkin.find_in_workspaces import find_in_workspaces package_name = 'pr_ordata' directory = 'data/objects' objects_path = find_in_workspaces( search_dirs=['share'], project=package_name, path=directory, first_match_only=True) if len(objects_path) == 0: print('Can\'t find directory %s %s' % (package_name, directory)) sys.exit() else: print objects_path objects_path = objects_path[0] env, robot = herbpy.initialize(sim=True, attach_viewer='rviz',segway_sim=True) #Add the table table_file = os.path.join(objects_path, 'table.kinbody.xml') table = env.ReadKinBodyXMLFile(table_file) #env.AddKinBody(table) if table == None: print('Failed to load table kinbody') sys.exit() env.AddKinBody(table) table_pose = np.array([[1., 0., 0., 2], [0., 0., -1., 2], [0., 1., 0., 0.], [0., 0., 0., 1.]]) table.SetTransform(table_pose)
logger = logging.getLogger(__name__) if __name__ == '__main__': import argparse parser = argparse.ArgumentParser(description="Demonstrate using push planner to make object graspable") parser.add_argument("-v", "--viewer", dest="viewer", default=None, help="The viewer to attach") parser.add_argument("-d", "--debug", action="store_true", help="Run in debug mode") parser.add_argument("-t", "--timeout", default=120.0, type=float, help="The max time to run the planner") args = parser.parse_args() import herbpy env, robot = herbpy.initialize(sim=True, attach_viewer=args.viewer) push_arm = robot.right_arm grasp_arm = robot.left_arm # Put the hand in a preshape for pushing push_arm.hand.MoveHand(spread=0, f1=0.75, f2=0.75, f3=0.75) # Table import os table_path = os.path.join('objects', 'table.kinbody.xml') table = env.ReadKinBodyXMLFile(table_path) import numpy, openravepy table_transform = numpy.eye(4) table_transform[:3, :3] = openravepy.rotationMatrixFromAxisAngle([1.20919958, 1.20919958, 1.20919958])
check = classify_ee_pos(eepos, table_pose) # 1 -> valid start_pos, 2 -> valid goal_pos, 0 -> invalid_pos if (check == 1 and len(start) < 50): start.append(random_node) elif (check == 2 and len(goal) < 50): goal.append(random_node) if (len(start) == 50 and len(goal) == 50): write_one_dir(task_id, env_no, start, goal, cond, binary_vec) else: print("no of start or goal posiitons is under limit") def generate_data(task_id, robot, env, G): if (task_id == "T1"): object_around_table(task_id, robot, env, G) if __name__ == '__main__': parser = argparse.ArgumentParser(description='Generate environments') parser.add_argument('--graphfile', type=str, required=True) args = parser.parse_args() env, robot = herbpy.initialize(sim=True, attach_viewer='interactivemarker') robot.right_arm.SetActive() G = nx.read_graphml(args.graphfile) generate_data("T1", robot, env, G) nx.write_graphml(G, "graphs/weighted_graph.graphml")
]] for i, jpos in enumerate(jpos_list): robot.SetActiveDOFValues(jpos, openravepy.KinBody.CheckLimitsAction.Nothing) robot.SetActiveDOFVelocities(numpy.zeros(7)) jtor = robot.ComputeInverseDynamics([]) print 'jpos[{}] gravtorques: {}'.format( i, ' '.join([ '{:7.3f}'.format(x) for x in jtor[robot.GetActiveDOFIndices()] ])) if __name__ == "__main__": openravepy.RaveInitialize(True) openravepy.misc.InitOpenRAVELogging() # herbpy_args = {'sim':args.sim, # 'attach_viewer':args.viewer, # 'robot_xml':args.robot_xml, # 'env_path':args.env_xml, # 'segway_sim':args.segway_sim} # if args.sim and not args.segway_sim: # herbpy_args['segway_sim'] = args.sim env, robot = herbpy.initialize(sim=True, segway_sim=True) iD()
help='robot XML file; defaults to herb_description') parser.add_argument('--env-xml', type=str, help='environment XML file; defaults to an empty environment') parser.add_argument('-b', '--segway-sim', action='store_true', help='simulate base') parser.add_argument('-p', '--perception-sim', action='store_true', help='simulate perception') parser.add_argument('--debug', action='store_true', help='enable debug logging') args = parser.parse_args() openravepy.RaveInitialize(True) openravepy.misc.InitOpenRAVELogging() if args.debug: openravepy.RaveSetDebugLevel(openravepy.DebugLevel.Debug) herbpy_args = {'sim':args.sim, 'attach_viewer':args.viewer, 'robot_xml':args.robot_xml, 'env_path':args.env_xml, 'segway_sim':args.segway_sim, 'perception_sim': args.perception_sim} if args.sim and not args.segway_sim: herbpy_args['segway_sim'] = args.sim env, robot = herbpy.initialize(**herbpy_args) import IPython IPython.embed()
service = rospy.ServiceProxy(service_name, DetectPlane); response = service(cloud_topic); return response except rospy.ServiceException, e: print "Service call failed: %s"%e rospy.init_node('table_detector',anonymous=True) from catkin.find_in_workspaces import find_in_workspaces objects_path = find_in_workspaces( search_dirs=['share'], project='pr_ordata', path='data/test', first_match_only=True)[0] env, robot = herbpy.initialize(sim=True,attach_viewer='interactivemarker') plane_file = os.path.join(objects_path, 'plane.xml') plane = env.ReadKinBodyXMLFile(plane_file) plane_resp = find_table_plane() plane_pose = numpy.array(quaternion_matrix([ plane_resp.pose.orientation.x, plane_resp.pose.orientation.y, plane_resp.pose.orientation.z, plane_resp.pose.orientation.w])) #plane_pose = numpy.eye(4) plane_pose[0,3] = plane_resp.pose.position.x plane_pose[1,3] = plane_resp.pose.position.y
def main(): """Execute demo for grasping glass.""" parser = argparse.ArgumentParser() parser.add_argument('--viewer', '-v', type=str, default='interactivemarker', help='The viewer to attach (none for no viewer)') parser.add_argument('--monitor', action='store_true', help='Display a UI to monitor progress of the planner') parser.add_argument('--planner', type=str, choices=['dfs', 'restart'], default='restart', help='The planner to use') parser.add_argument('--robot', type=str, default='herb', help='Robot to run the task on') openravepy.RaveInitialize(True, level=openravepy.DebugLevel.Info) openravepy.misc.InitOpenRAVELogging() args = parser.parse_args() env, robot = herbpy.initialize() # Get the desired manipulator manipulator = robot.GetManipulator('right') if args.viewer != 'none': env.SetViewer(args.viewer) monitor = None # Create a monitor if args.monitor: monitor = magi.monitor.ActionMonitor() def signal_handler(signum, frame): """Signal handler to gracefully kill the monitor.""" monitor.stop() sys.exit(0) signal.signal(signal.SIGINT, signal_handler) signal.signal(signal.SIGTERM, signal_handler) # Create a planner if args.planner == 'restart': planner = RestartPlanner(monitor=monitor) elif args.planner == 'dfs': planner = DepthFirstPlanner(monitor=monitor, use_frustration=True) if monitor is not None: monitor.reset() # Detect objects table, glass = detect_objects(robot) try: # Create the task. action = grasp_glass_action_graph(manipulator, glass, table) # Plan the task with env: solution = planner.plan_action(env, action) # Execute the task execute_pipeline(env, solution, simulate=True, monitor=monitor) except ActionError as err: LOGGER.info('Failed to complete planning for task: %s', str(err)) raise except ExecutionError as err: LOGGER.info('Failed to execute task: %s', str(err)) raise IPython.embed() if monitor: monitor.stop()
def main(): parser = argparse.ArgumentParser(description='Generate environments') parser.add_argument('--condnsfile', type=str, required=True) parser.add_argument('--graphfile', type=str, required=True) args = parser.parse_args() G = nx.read_graphml(args.graphfile) env, robot = herbpy.initialize(sim=True, attach_viewer='interactivemarker') robot.right_arm.SetActive() # Load table from pr_ordata table_file = os.path.join(objects_path, 'objects/table.kinbody.xml') table = env.ReadKinBodyXMLFile(table_file) env.AddKinBody(table) xpos, ypos = get_table_pose(args.condnsfile) pp_no = 5 table_pose[0, 3] = xpos table_pose[1, 3] = ypos table.SetTransform(table_pose) count = 0 topic = 'output_node_pos' publisher = rospy.Publisher(topic, MarkerArray) topic = 'expected_node_pos' publisher1 = rospy.Publisher(topic, MarkerArray) rospy.init_node('output_node_pos') markerArray = MarkerArray() p_file_addr = "output_data/output_samples.txt" eepositions = get_eepositions_from_samples(env, robot, p_file_addr) path_node_file_addr = "output_data/expected_path_nodes.txt" markerArray1 = get_markers_expected_samples(G, env, robot, path_node_file_addr) while not rospy.is_shutdown(): markerArray = MarkerArray() eepositions, markerArray = load_marker(eepositions, markerArray) print("len(eepositions) = ", len(eepositions)) id = 0 for m in markerArray.markers: m.id = id id += 1 # Publish the MarkerArray publisher.publish(markerArray) for m in markerArray1.markers: m.id = id id += 1 publisher1.publish(markerArray1) # print("len(markerArray1) = ", len(markerArray1)) count += 1 rospy.sleep(0.1)
if args.debug: openravepy.RaveSetDebugLevel(openravepy.DebugLevel.Debug) herbpy_args = { 'sim': args.sim, 'attach_viewer': args.viewer, 'robot_xml': args.robot_xml, 'env_path': args.env_xml, 'segway_sim': args.segway_sim, 'perception_sim': args.perception_sim } if args.sim and not args.segway_sim: herbpy_args['segway_sim'] = args.sim env, robot = herbpy.initialize(**herbpy_args) #Add in canvas cube from openravepy import * body = RaveCreateKinBody(env, '') body.SetName('testbody') body.InitFromBoxes(numpy.array( [[0.6, 0, 1, 0.01, 0.2, 0.3]]), True) # set geometry as one box of extents 0.1, 0.2, 0.3 env.AddKinBody(body) #Todo make center expressed in meters dm = DrawingManager(robot, robot.right_arm, numpy.array([1, 0, 0]), numpy.array([0.6, 0, 1]), numpy.array([11.5, 9]), body) import IPython IPython.embed()
#!/usr/bin/env python import herbpy import numpy if __name__ == '__main__': env, robot = herbpy.initialize() keep_going = True while keep_going: print "\n\nWelcome to the gesture control:\n \ Press W to wave.\n \ Press S to say something.\n \ Press Y to nod 'yes'.\n \ Press N to nod 'no'.\n \ Press H to high five.\n \ Press P to point at an object.\n \ Press S to present an object.\n \ Press R to reset the robot.\n \ Press Q to quit.\n" user_input = raw_input("Gesture? ") if user_input == 'Q': print 'Goodbye!\n' keep_going = False elif user_input == 'W': print 'Waving!\n' robot.Wave() elif user_input == 'Y': print 'Nodding yes!\n'
help="The environment to load") parser.add_argument("--robot", type=str, default="herb", help="The robot to use for the FK test") parser.add_argument("--manip", type=str, default="right", help="The manipulator to use for the FK test") parser.add_argument("--random", type=int, default=50000, help="The number of random poses to check. This will be ignored if the test parameters is set.") parser.add_argument("--viewer", type=str, default=None, help="The viewer to attach to the environment") args = parser.parse_args() # Load the environment if args.robot == 'herb': env, robot = herbpy.initialize(sim=True, attach_viewer=args.viewer) else: env = openravepy.Environment() if args.env: env.Load(args.env) # Verify the kinbody is in the environment body = env.GetKinBody(args.robot) if body is None: raise Exception('No robot with name %s in environment. Failing.' % args.robot) # Load the openrave module try: module = openravepy.RaveCreateModule(env, 'kinematicbenchmarks') except openravepy.openrave_exception:
#!/usr/bin/env python import logging import rospy import herbpy import humanpy.humandetection as humdet if __name__ == "__main__": logger = logging.getLogger('test_skel_herb') logger.setLevel(logging.INFO) rospy.init_node('humkin2') segway_sim = rospy.get_param("~seg_sim"); env, herb = herbpy.initialize(attach_viewer='InteractiveMarker', segway_sim=segway_sim) if segway_sim==True: refsys = '/head/skel_depth_frame2' else: refsys = '/head/skel_depth_frame' humdet.DetectHuman(env, orhuman='kin2_or', segway_sim=segway_sim, kin_frame=refsys)