rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
def create_joint_angles_traj(self, arm, q_arr, dur_arr): | def create_JTG(self, arm, q_arr, dur_arr, stamp=None): | def create_joint_angles_traj(self, arm, q_arr, dur_arr): if arm != 1: arm = 0 jtg = JointTrajectoryGoal() jtg.trajectory.joint_names = self.joint_names_list[arm] for i in range(len(q_arr)): if q_arr[i] is None or type(q_arr[i]) is types.NoneType: continue jtp = JointTrajectoryPoint() jtp.positions = q_arr[i] jtp.veloci... |
def set_joint_angles(self, arm, q, duration=1.): if arm != 1: arm = 0 self.jtg = self.create_joint_angles_traj(arm, [q], [duration]) self.arm_state_lock[arm].acquire() self.joint_action_client[arm].send_goal(self.jtg) self.arm_state_lock[arm].release() | def set_joint_angles(self, arm, q, duration=1., start_time=0.): self.set_joint_angles_traj(arm, [q], [duration], start_time) | def set_joint_angles(self, arm, q, duration=1.): if arm != 1: arm = 0 self.jtg = self.create_joint_angles_traj(arm, [q], [duration]) self.arm_state_lock[arm].acquire() self.joint_action_client[arm].send_goal(self.jtg) self.arm_state_lock[arm].release() |
def set_joint_angles_traj(self, arm, q_arr, dur_arr): | def set_joint_angles_traj(self, arm, q_arr, dur_arr, start_time=0.): | def set_joint_angles_traj(self, arm, q_arr, dur_arr): if arm != 1: arm = 0 self.jtg = create_joint_angles_traj(arm, q_arr, dur_arr) self.arm_state_lock[arm].acquire() self.joint_action_client[arm].send_goal(self.jtg) self.arm_state_lock[arm].release() |
self.jtg = create_joint_angles_traj(arm, q_arr, dur_arr) self.arm_state_lock[arm].acquire() self.joint_action_client[arm].send_goal(self.jtg) self.arm_state_lock[arm].release() | jtg = self.create_JTG(arm, q_arr, dur_arr) cur_time = rospy.Time.now().to_sec() jtg.trajectory.header.stamp = rospy.Duration(start_time + cur_time) self.execute_trajectory(arm, jtg) | def set_joint_angles_traj(self, arm, q_arr, dur_arr): if arm != 1: arm = 0 self.jtg = create_joint_angles_traj(arm, q_arr, dur_arr) self.arm_state_lock[arm].acquire() self.joint_action_client[arm].send_goal(self.jtg) self.arm_state_lock[arm].release() |
invquatmat = np.mat(tftrans.quaternion_matrix(tftrans.quaternion_inverse(quat))) invquatmat[0:3,3] = np.matrix(pos).T trans = np.matrix([self.off_point[0],self.off_point[1],self.off_point[2],1.]).T transpos = invquatmat * trans return np.resize(transpos, (3, 1)) | pos = make_column(pos) quat = make_list(quat) invquatmat = np.mat(tftrans.quaternion_matrix(quat)) invquatmat[0:3,3] = pos trans = np.matrix([off_point[0],off_point[1],off_point[2],1.]).T transpos = invquatmat * trans return np.resize(transpos, (3, 1)) | def transform_in_frame(self, pos, quat, off_point): invquatmat = np.mat(tftrans.quaternion_matrix(tftrans.quaternion_inverse(quat))) invquatmat[0:3,3] = np.matrix(pos).T trans = np.matrix([self.off_point[0],self.off_point[1],self.off_point[2],1.]).T transpos = invquatmat * trans return np.resize(transpos, (3, 1)) |
self.arm_state_lock[arm].acquire() | def FK(self, arm, q): if arm != 1: arm = 0 fk_req = GetPositionFKRequest() fk_req.header.frame_id = 'torso_lift_link' if arm == 0: fk_req.fk_link_names.append('r_wrist_roll_link') # gripper_tool_frame else: fk_req.fk_link_names.append('l_wrist_roll_link') fk_req.robot_state.joint_state.name = self.joint_names_list[arm]... | |
self.arm_state_lock[arm].release() | def FK(self, arm, q): if arm != 1: arm = 0 fk_req = GetPositionFKRequest() fk_req.header.frame_id = 'torso_lift_link' if arm == 0: fk_req.fk_link_names.append('r_wrist_roll_link') # gripper_tool_frame else: fk_req.fk_link_names.append('l_wrist_roll_link') fk_req.robot_state.joint_state.name = self.joint_names_list[arm]... | |
ret1 = self.transform_in_frame([x,y,z], quat, off_point) | ret1 = self.transform_in_frame([x,y,z], quat, self.off_point) | def FK(self, arm, q): if arm != 1: arm = 0 fk_req = GetPositionFKRequest() fk_req.header.frame_id = 'torso_lift_link' if arm == 0: fk_req.fk_link_names.append('r_wrist_roll_link') # gripper_tool_frame else: fk_req.fk_link_names.append('l_wrist_roll_link') fk_req.robot_state.joint_state.name = self.joint_names_list[arm]... |
if rot[:].shape == (3, 3): | p = make_column(p) if rot.shape == (3, 3): | def IK(self, arm, p, rot, q_guess): if arm != 1: arm = 0 |
elif rot[:].shape == (4, 1): quat = np.matrix(rot) | elif rot.shape == (4, 1): quat = make_column(rot) | def IK(self, arm, p, rot, q_guess): if arm != 1: arm = 0 |
transpos = self.transform_in_frame(p.T.A[0], quat.T.A[0], neg_off) | transpos = self.transform_in_frame(p, quat, neg_off) | def IK(self, arm, p, rot, q_guess): if arm != 1: arm = 0 |
self.arm_state_lock[arm].acquire() | def IK(self, arm, p, rot, q_guess): if arm != 1: arm = 0 | |
self.arm_state_lock[arm].release() | def IK(self, arm, p, rot, q_guess): if arm != 1: arm = 0 | |
def move_arm(self, arm, pos, rot=None, dur=1.0): | def move_arm(self, arm, pos, rot=None, dur=4.0): | def move_arm(self, arm, pos, rot=None, dur=1.0): begq = self.get_joint_angles(arm) if rot is None: temp, rot = self.FK(arm, begq) endq = self.IK(arm, pos, rot, begq) if endq is None: return False self.set_joint_angles(arm, endq, dur) return True |
if arm == 0: q = self.r_arm_angles else: q = self.l_arm_angles | q = self.arm_angles[arm] | def get_joint_angles(self, arm): if arm != 1: arm = 0 self.arm_state_lock[arm].acquire() if arm == 0: q = self.r_arm_angles else: q = self.l_arm_angles self.arm_state_lock[arm].release() return q |
def _smooth_traj_pos(t, k, T): return -k / T**3 * np.sin(T * t) + k / T**2 * t def _smooth_traj_vel(t, k, T): return -k / T**2 * np.cos(T * t) + k / T**2 def _smooth_traj_acc(t, k, T): return k / T * np.sin(T * t) def _smooth_traj_time(l, k): return np.power(4 * np.pi**2 * l / k, 1./3.) def _interpolate_traj(traj,... | # def get_wrist_force(self, arm): | |
def smooth_linear_move_arm(self, arm, dist, dir=(0.,0.,-1.), max_jerk=0.5, delta=0.01, dur=None): | def smooth_linear_arm_trajectory(self, arm, dist, dir=(0.,0.,-1.), max_jerk=0.5, delta=0.01, dur=None): def _smooth_traj_pos(t, k, T): return -k / T**3 * np.sin(T * t) + k / T**2 * t def _smooth_traj_time(l, k): return np.power(4 * np.pi**2 * l / k, 1./3.) def _interpolate_traj(traj, k, T, num=10, begt=0., ... | def smooth_linear_move_arm(self, arm, dist, dir=(0.,0.,-1.), max_jerk=0.5, delta=0.01, dur=None): # Vector representing full transform of end effector traj_vec = [x/np.sqrt(np.vdot(dir,dir)) for x in dir] # number of steps to interpolate trajectory over num_steps = dist / delta # period of the trajectory trajt = _smoot... |
print "trajt:", trajt | def smooth_linear_move_arm(self, arm, dist, dir=(0.,0.,-1.), max_jerk=0.5, delta=0.01, dur=None): # Vector representing full transform of end effector traj_vec = [x/np.sqrt(np.vdot(dir,dir)) for x in dir] # number of steps to interpolate trajectory over num_steps = dist / delta # period of the trajectory trajt = _smoot... | |
param_list[1] = False | break | def relay_cb(og, og_pub): rospy.logout('relay_cb called') og3d = rog.og_msg_to_og3d(og) og_new = rog.og3d_to_og_msg(og3d) og_pub.publish(og_new) |
def create_goal_pose(x, y, z, gripper_rot= 0.): | def create_gripper_pose(x, y, z, quat): point = [x, y, z] point = transform_in_frame(point, np.array(quat), -GRIPPER_POINT).tolist() pose = point + quat goal_pose = cf.create_pose_stamped(pose, "torso_lift_link") goal_pose.header.stamp = rospy.Time.now() return goal_pose def get_gripper_pose(gripper_rot): | def create_goal_pose(x, y, z, gripper_rot= 0.): gripper_rot = normalize_rot(gripper_rot) quat1 = quaternion_about_axis(np.pi/2., (0, 1, 0)) quat2 = quaternion_about_axis(gripper_rot, (0, 0, 1)) quat = quaternion_multiply(quat2, quat1) point = [x, y, z] point = transform_in_frame(point, quat, -GRIPPER_POINT).tolist() po... |
point = transform_in_frame(point, quat, -GRIPPER_POINT).tolist() pose = point + quat.tolist() | point = transform_in_frame(point, gripper_pose, -GRIPPER_POINT).tolist() pose = point + gripper_pose.tolist() | def create_goal_pose(x, y, z, gripper_rot= 0.): gripper_rot = normalize_rot(gripper_rot) quat1 = quaternion_about_axis(np.pi/2., (0, 1, 0)) quat2 = quaternion_about_axis(gripper_rot, (0, 0, 1)) quat = quaternion_multiply(quat2, quat1) point = [x, y, z] point = transform_in_frame(point, quat, -GRIPPER_POINT).tolist() po... |
grasp_pose = create_goal_pose(xyr[0], xyr[1], HOVER_Z, gripper_rot = xyr[2]) | grasp_pose = create_goal_pose(xyr[0], xyr[1], HOVER_Z, get_gripper_pose(xyr[2])) | def collect_grasp_data(generate_models=False, skip_grasp=False): cm = ControllerManager(armc) apm = ArmPerceptionMonitor(ARM, percept_mon_list=None) # if restart: # grasp_data = load_pickle(GRASP_DATA) # grasp_xyr_list = zip(*grasp_data)[0] # else: # grasp_xyr_list = get_xy_list() # g... |
HOVER_Z - GRASP_DIST, gripper_rot=xyr[2]) | HOVER_Z - GRASP_DIST, get_gripper_pose(xyr[2])) | def collect_grasp_data(generate_models=False, skip_grasp=False): cm = ControllerManager(armc) apm = ArmPerceptionMonitor(ARM, percept_mon_list=None) # if restart: # grasp_data = load_pickle(GRASP_DATA) # grasp_xyr_list = zip(*grasp_data)[0] # else: # grasp_xyr_list = get_xy_list() # g... |
grasp_pose = create_goal_pose(x, y, HOVER_Z, gripper_rot) | grasp_pose = create_goal_pose(x, y, HOVER_Z, get_gripper_pose(gripper_rot)) | def perform_grasp(x, y, z=None, gripper_rot = np.pi / 2., grasp=None, is_place=False, is_grasp=True, collide = True, return_pose=True, zeros = None, cm=None, apm=None): print "Performing grasp (%1.2f, %1.2f), rotation: %1.2f" % (x, y, gripper_rot) gripper_rot = normalize_rot(gripper_rot) if cm is None: cm = Controller... |
goal_pose = create_goal_pose(x, y, HOVER_Z - GRASP_DIST, gripper_rot) | goal_pose = create_goal_pose(x, y, HOVER_Z - GRASP_DIST, get_gripper_pose(gripper_rot)) | def perform_grasp(x, y, z=None, gripper_rot = np.pi / 2., grasp=None, is_place=False, is_grasp=True, collide = True, return_pose=True, zeros = None, cm=None, apm=None): print "Performing grasp (%1.2f, %1.2f), rotation: %1.2f" % (x, y, gripper_rot) gripper_rot = normalize_rot(gripper_rot) if cm is None: cm = Controller... |
signals = models[percept]["smoothed_signals"] noise_var = models[percept]["noise_variance"] noise_dev = np.sqrt(noise_var) | if "smoothed_signals" in models[percept]: signals = models[percept]["smoothed_signals"] zip_signals = [ zip(*sig) for sig in signals ] else: signals = None zip_signals = [] if "noise_variance" in models[percept]: noise_var = models[percept]["noise_variance"] noise_dev = np.sqrt(noise_var) else: noise_var = None noise_d... | def display_grasp_data(grasps, percept="accelerometer", indicies=range(3), std_dev=STD_DEV, noise_dev_add=NOISE_DEV, monitor_data=[], std_dev_dict=STD_DEV_DICT, tol_thresh_dict=TOL_THRESH_DICT, model_zeros=None, monitor_zeros=None, plot_data=False, colors=None): import matplotlib.pyplot as plt if colors is None: colors... |
zip_signals = [ zip(*sig) for sig in signals ] | def display_grasp_data(grasps, percept="accelerometer", indicies=range(3), std_dev=STD_DEV, noise_dev_add=NOISE_DEV, monitor_data=[], std_dev_dict=STD_DEV_DICT, tol_thresh_dict=TOL_THRESH_DICT, model_zeros=None, monitor_zeros=None, plot_data=False, colors=None): import matplotlib.pyplot as plt if colors is None: colors... | |
mmax += [graph_means[w] + graph_devs[w] * std_dev + noise_dev[w] * noise_dev_add | if noise_dev is not None: noise_dev_term = noise_dev[w] * noise_dev_add else: noise_dev_term = 0. mmax += [graph_means[w] + graph_devs[w] * std_dev + noise_dev_term | def display_grasp_data(grasps, percept="accelerometer", indicies=range(3), std_dev=STD_DEV, noise_dev_add=NOISE_DEV, monitor_data=[], std_dev_dict=STD_DEV_DICT, tol_thresh_dict=TOL_THRESH_DICT, model_zeros=None, monitor_zeros=None, plot_data=False, colors=None): import matplotlib.pyplot as plt if colors is None: colors... |
mmin += [graph_means[w] - graph_devs[w] * std_dev - noise_dev[w] * noise_dev_add | mmin += [graph_means[w] - graph_devs[w] * std_dev - noise_dev_term | def display_grasp_data(grasps, percept="accelerometer", indicies=range(3), std_dev=STD_DEV, noise_dev_add=NOISE_DEV, monitor_data=[], std_dev_dict=STD_DEV_DICT, tol_thresh_dict=TOL_THRESH_DICT, model_zeros=None, monitor_zeros=None, plot_data=False, colors=None): import matplotlib.pyplot as plt if colors is None: colors... |
zip_monitor = zip_monitors[i] len_diff = len(graph_means[k]) - len(zip_monitor[indicies[k]]) add_vals = [zip_monitor[indicies[k]][0]] * MONITOR_WINDOW print len_diff g = np.array(add_vals + list(zip_monitor[indicies[k]])) g += grasp[4][percept][indicies[k]] - monitor_zeros[i][percept][indicies[k]] plt.plot(g.tolist(),... | if i < len(zip_monitors): zip_monitor = zip_monitors[i] len_diff = len(graph_means[k]) - len(zip_monitor[indicies[k]]) add_vals = [zip_monitor[indicies[k]][0]] * MONITOR_WINDOW print len_diff g = np.array(add_vals + list(zip_monitor[indicies[k]])) g += grasp[4][percept][indicies[k]] - monitor_zeros[i][percept][indicie... | def display_grasp_data(grasps, percept="accelerometer", indicies=range(3), std_dev=STD_DEV, noise_dev_add=NOISE_DEV, monitor_data=[], std_dev_dict=STD_DEV_DICT, tol_thresh_dict=TOL_THRESH_DICT, model_zeros=None, monitor_zeros=None, plot_data=False, colors=None): import matplotlib.pyplot as plt if colors is None: colors... |
save_pickle(grasp_data, GRASP_DATA_FILE) | def process_data(grasp_data=None): print "Loading data" if grasp_data is None: grasp_data = load_pickle(GRASP_DATA_FILE) grasp_data = load_data_and_generate(grasp_data) print "Saving models" save_pickle(grasp_data, GRASP_DATA_FILE) print "Trimming test data" model_data = trim_test_data(grasp_data) print "Splitting mode... | |
collide=True, is_grasp = False, | collide=True, is_grasp = True, | def main(): rospy.init_node(node_name) # rospy.on_shutdown(die) setup_package_loc() ki = KeyboardInput() #grasp_data = collect_grasp_data(generate_models=False, skip_grasp=False) #return 0 #process_data(grasp_data) #return 0 #trim_test_data() # return 0 #split_model_data() #return 0 # print get_grasp_model(0., 0.)... |
print 'OmniPR2Teleop: control ENABLED.' | rospy.loginfo('control ENABLED.') | def set_state(self, s): self.enabled = s if self.enabled: print 'OmniPR2Teleop: control ENABLED.' self.left_controller.set_control(True) self.left_feedback.set_enable(True) #self.right_controller.set_control(True) else: print 'OmniPR2Teleop: control disabled. Follow potential well to pose of arm.' self.left_controller... |
self.left_feedback.set_enable(True) | def set_state(self, s): self.enabled = s if self.enabled: print 'OmniPR2Teleop: control ENABLED.' self.left_controller.set_control(True) self.left_feedback.set_enable(True) #self.right_controller.set_control(True) else: print 'OmniPR2Teleop: control disabled. Follow potential well to pose of arm.' self.left_controller... | |
print 'OmniPR2Teleop: control disabled. Follow potential well to pose of arm.' | rospy.loginfo('control disabled. Follow potential well to pose of arm.') | def set_state(self, s): self.enabled = s if self.enabled: print 'OmniPR2Teleop: control ENABLED.' self.left_controller.set_control(True) self.left_feedback.set_enable(True) #self.right_controller.set_control(True) else: print 'OmniPR2Teleop: control disabled. Follow potential well to pose of arm.' self.left_controller... |
self.left_feedback.set_enable(False) | def set_state(self, s): self.enabled = s if self.enabled: print 'OmniPR2Teleop: control ENABLED.' self.left_controller.set_control(True) self.left_feedback.set_enable(True) #self.right_controller.set_control(True) else: print 'OmniPR2Teleop: control disabled. Follow potential well to pose of arm.' self.left_controller... | |
print 'OmniPR2Teleop: running...' | rospy.loginfo('running...') | def run(self): rate = rospy.Rate(10.0) print 'OmniPR2Teleop: running...' while not rospy.is_shutdown(): self.left_controller.send_transform_to_link_omni_and_pr2_frame() rate.sleep() |
results = [ '', -1 ] | results = [[ '', -1 ]] | def run( self ): while self.should_run: if self.mode == self.QUERY_MODE: for aF in self.antFuncs: antennaName = aF(self.reader) # let current antFunc make appropriate changes results = self.reader.QueryEnvironment() if len(results) == 0: results = [ '', -1 ] # [ tagid, rssi ] #datum = [antennaName, '', -1] #[cF(datu... |
class PeriodicMonitor(): | class PeriodicLogger(): | def accel_state_processor(msg): accel_msg = ros_to_dict(msg) x, y, z = 0., 0., 0. if msg.samples is None or len(msg.samples) == 0: return None for samp in msg.samples: x += samp.x y += samp.y z += samp.z x /= len(msg.samples) y /= len(msg.samples) z /= len(msg.samples) return (msg.header.stamp.to_nsec(), (x, y, z)) |
if self.is_running: return | def start(self, num_calls=None): self.num_calls = num_calls if self.is_running: return self.is_running = True self._run() | |
def __init__(self, arm, rate): | def __init__(self, arm, rate=0.01): | def __init__(self, arm, rate): log("Initializing arm perception listeners") |
self.cbs = [self.accel_listener.read] | self.perceptions = { "accelerometer" : self.accel_listener.read } | def __init__(self, arm, rate): log("Initializing arm perception listeners") |
self.pmonitors = [None] * len(self.cbs) self.datasets = [None] * len(self.cbs) | self.pmonitors = {} self.datasets = {} for k in self.perceptions: self.pmonitors[k] = None self.datasets[k] = None self.active = False self.cur_means_model = None self.cur_variance_model = None | def __init__(self, arm, rate): log("Initializing arm perception listeners") |
def start(self, duration=None): for i in range(len(self.cbs)): self.pmonitors[i] = PeriodicMonitor(self.cbs[i], self.rate) for i in range(len(self.cbs)): | def start_training(self, duration=None): if self.active: log("Perception already active.") return self.active = True for k in self.perceptions: self.pmonitors[k] = PeriodicLogger(self.perceptions[k], self.rate) self.datasets[k] = None for k in self.perceptions: | def start(self, duration=None): for i in range(len(self.cbs)): self.pmonitors[i] = PeriodicMonitor(self.cbs[i], self.rate) |
self.pmonitors[i].start() | self.pmonitors[k].start() | def start(self, duration=None): for i in range(len(self.cbs)): self.pmonitors[i] = PeriodicMonitor(self.cbs[i], self.rate) |
self.pmonitors[i].start(int(duration / self.rate) + 1) | self.pmonitors[k].start(int(duration / self.rate) + 1) | def start(self, duration=None): for i in range(len(self.cbs)): self.pmonitors[i] = PeriodicMonitor(self.cbs[i], self.rate) |
threading.Timer(self._wait_stop, duration) def stop(self): for i in range(len(self.cbs)): if self.datasets[i] is None: self.datasets[i] = [self.pmonitors[i].stop()] | threading.Timer(self._wait_stop_training, duration) def stop_training(self): if not self.active: log("Nothing to stop.") return for k in self.perceptions: if self.datasets[k] is None: self.datasets[k] = [self.pmonitors[k].stop()] | def start(self, duration=None): for i in range(len(self.cbs)): self.pmonitors[i] = PeriodicMonitor(self.cbs[i], self.rate) |
self.datasets[i] += [self.pmonitors[i].stop()] | self.datasets[k] += [self.pmonitors[k].stop()] self.active = False | def stop(self): for i in range(len(self.cbs)): if self.datasets[i] is None: self.datasets[i] = [self.pmonitors[i].stop()] else: self.datasets[i] += [self.pmonitors[i].stop()] |
def _wait_stop(self): for i in range(len(self.cbs)): | def _wait_stop_training(self): if not self.active: log("Nothing to stop.") return for k in self.perceptions: | def _wait_stop(self): for i in range(len(self.cbs)): dataset = None while dataset is None: dataset = self.pmonitors[i].get_ret_vals() |
dataset = self.pmonitors[i].get_ret_vals() if self.datasets[i] is None: self.datasets[i] = [dataset] | dataset = self.pmonitors[k].get_ret_vals() if self.datasets[k] is None: self.datasets[k] = [dataset] | def _wait_stop(self): for i in range(len(self.cbs)): dataset = None while dataset is None: dataset = self.pmonitors[i].get_ret_vals() |
self.datasets[i] += [dataset] | self.datasets[k] += [dataset] self.active = False | def _wait_stop(self): for i in range(len(self.cbs)): dataset = None while dataset is None: dataset = self.pmonitors[i].get_ret_vals() |
def generate_model(self, i, smooth_wind=50, var_wind=30, var_smooth_wind=30): if datasets[i] is None: | def generate_model(self, perception, smooth_wind=None, var_wind=None, var_smooth_wind=None): model_list = self.datasets[perception] import pdb; pdb.set_trace() if model_list is None: | def generate_model(self, i, smooth_wind=50, var_wind=30, var_smooth_wind=30): if datasets[i] is None: log("No data to generate model for") return None |
num_coords = len(self.datasets[i][0][0][1]) | num_coords = len(model_list[0][0][1]) | def generate_model(self, i, smooth_wind=50, var_wind=30, var_smooth_wind=30): if datasets[i] is None: log("No data to generate model for") return None |
for model in self.datasets[i]: | for model in model_list: | def generate_model(self, i, smooth_wind=50, var_wind=30, var_smooth_wind=30): if datasets[i] is None: log("No data to generate model for") return None |
sig_var = signal_variance(model_coord, cur_mean_model, var_wind)] | sig_var = signal_variance(model_coord, cur_mean_model, var_wind) | def generate_model(self, i, smooth_wind=50, var_wind=30, var_smooth_wind=30): if datasets[i] is None: log("No data to generate model for") return None |
lens = [len(a) for a in mean_models] min_len = np.min(lens) | def generate_model(self, i, smooth_wind=50, var_wind=30, var_smooth_wind=30): if datasets[i] is None: log("No data to generate model for") return None | |
avg_means_model += [sum_mean / num_models] avg_vars_model += [sum_var / num_models] | avg_mean = sum_mean / num_models avg_var = sum_var / num_models sum_model_var = 0. for j in range(num_models): sum_model_var += (mean_models[j][k] - avg_mean) ** 2 total_model_var = sum_model_var / num_models + avg_var avg_means_model += [avg_mean] avg_vars_model += [total_model_var] | def generate_model(self, i, smooth_wind=50, var_wind=30, var_smooth_wind=30): if datasets[i] is None: log("No data to generate model for") return None |
apm.start() | apm.start_training() | def generate_model(self, i, smooth_wind=50, var_wind=30, var_smooth_wind=30): if datasets[i] is None: log("No data to generate model for") return None |
apm.stop() means, vars = apm.generate_model(0, 100, 50) | apm.stop_training() means, vars = apm.generate_model("accelerometer", 100, 50) | def generate_model(self, i, smooth_wind=50, var_wind=30, var_smooth_wind=30): if datasets[i] is None: log("No data to generate model for") return None |
m.header.stamp = rospy.get_ros_time() | m.header.stamp = rospy.get_rostime() | def manipulate_cartesian_behavior(self, data, bf_T_obj, offset=np.matrix([.01,0,-.01]).T): rospy.loginfo('STATE manipulate') rospy.loginfo('there are %d states' % len(data['movement_states'])) rospy.loginfo('switching controllers') self.robot.controller_manager.switch(['l_cart', 'r_cart'], ['l_arm_controller', 'r_arm_c... |
cmd = 'rosbag record -O %s imitate_behavior_marker /pressure/l_gripper_motor /pressure/r_gripper_motor /accelerometer/l_gripper_motor /accelerometer/r_gripper_motor /joint_states /l_cart/command_pose /l_cart/command_posture /l_cart/state /r_cart/command_pose /r_cart/command_posture /r_cart/state /head_traj_controller/c... | cmd = 'rosbag record -O %s /imitate_behavior_marker /pressure/l_gripper_motor /pressure/r_gripper_motor /accelerometer/l_gripper_motor /accelerometer/r_gripper_motor /joint_states /l_cart/command_pose /l_cart/command_posture /l_cart/state /r_cart/command_pose /r_cart/command_posture /r_cart/state /head_traj_controller/... | def run_explore(self, data_fname): rospy.loginfo('loading demonstration pickle') data = ut.load_pickle(data_fname) #pdb.set_trace() #self.coarse_drive_behavior(data) rospy.loginfo('posing robot') self.pose_robot_behavior(data) #pdb.set_trace() |
stop_func = self._tactile_stop_func | stop_func = self._check_gripper_event | def _process_stop_option(self, stop): if stop == 'none': stop_func = None |
rospy.logdebug('Running at ' + (1./(t1 - t0)) + ' hz.') | rospy.logdebug('Running at ' + str(1./(t1 - t0)) + ' hz.') | def run(self): try: while not rospy.is_shutdown(): t0 = time.time() self.video_lock.acquire() frames = list(self.video.next()) result = self.detector.run(frames, display=self.display, debug=self.debug) self.video_lock.release() if result != None: p = result['point'] ps = PointStamped() ps.header.stamp = rospy.get_rost... |
loc = self.current_location()[0] | loc_bl = self.current_location()[0] | def reach(self, point, pressure_thres, move_back_distance): self.set_pressure_threshold(pressure_thres) loc = self.current_location()[0] front_loc = point.copy() front_loc[0,0] = loc[0,0] |
front_loc[0,0] = loc[0,0] | front_loc[0,0] = loc_bl[0,0] | def reach(self, point, pressure_thres, move_back_distance): self.set_pressure_threshold(pressure_thres) loc = self.current_location()[0] front_loc = point.copy() front_loc[0,0] = loc[0,0] |
touch_loc = self.current_location() | touch_loc_bl = self.current_location() | def reach(self, point, pressure_thres, move_back_distance): self.set_pressure_threshold(pressure_thres) loc = self.current_location()[0] front_loc = point.copy() front_loc[0,0] = loc[0,0] |
return True, r2, touch_loc | return True, r2, touch_loc_bl | def reach(self, point, pressure_thres, move_back_distance): self.set_pressure_threshold(pressure_thres) loc = self.current_location()[0] front_loc = point.copy() front_loc[0,0] = loc[0,0] |
def start_gripper_event_detector(self, event_type = 'all', accel = 3.25, slip=.008, blocking = 0, timeout = 15.): | def start_gripper_event_detector(self, event_type = 'all', accel = 5.25, slip=.008, blocking = 0, timeout = 15.): | def start_gripper_event_detector(self, event_type = 'all', accel = 3.25, slip=.008, blocking = 0, timeout = 15.): goal = PR2GripperEventDetectorGoal() if event_type == 'accel': goal.command.trigger_conditions = goal.command.ACC elif event_type == 'slip': goal.command.trigger_conditions = goal.command.SLIP elif event_t... |
self.start_location = (np.matrix([0.25, 0.10, 1.3]).T, np.matrix([0., 0., 0., 0.1])) | self.start_location = (np.matrix([0.25, 0.30, 1.3]).T, np.matrix([0., 0., 0., 0.1])) self.behaviors.move_absolute(self.start_location, stop='pressure_accel') | def __init__(self): rospy.init_node('linear_move', anonymous=True) self.tf_listener = tf.TransformListener() self.behaviors = Behaviors('l', tf_listener=self.tf_listener) self.robot = pr2.PR2(self.tf_listener) self.laser_scan = hd.LaserScanner('point_cloud_srv') #self.prosilica = rc.Prosilica('prosilica', 'streaming') ... |
rospy.loginfo('REACHING') | rospy.loginfo('REACHING to ' + str(point)) | def light_switch1(self, point, point_offset, press_contact_pressure, move_back_distance, press_pressure, press_distance, visual_change_thres): print '====================================================================' point = point + point_offset rospy.loginfo('REACHING') #self.behaviors.gripper_close() self.behavior... |
success, reason, touchloc = self.behaviors.reach(point, press_contact_pressure, move_back_distance) | success, reason, touchloc_bl = self.behaviors.reach(point, press_contact_pressure, move_back_distance) | def light_switch1(self, point, point_offset, press_contact_pressure, move_back_distance, press_pressure, press_distance, visual_change_thres): print '====================================================================' point = point + point_offset rospy.loginfo('REACHING') #self.behaviors.gripper_close() self.behavior... |
return change, touchloc | return change, touchloc_bl | def light_switch1(self, point, point_offset, press_contact_pressure, move_back_distance, press_pressure, press_distance, visual_change_thres): print '====================================================================' point = point + point_offset rospy.loginfo('REACHING') #self.behaviors.gripper_close() self.behavior... |
points = self.laser_scan.scan(math.radians(180.), math.radians(-180.), 10.) | points = self.laser_scan.scan(math.radians(180.), math.radians(-180.), 40.) | def record_perceptual_data(self, point_touched_bl): #what position should the robot be in? #set arms to non-occluding pose |
'point_touched': point_touched, | 'point_touched': point_touched_bl, | def record_perceptual_data(self, point_touched_bl): #what position should the robot be in? #set arms to non-occluding pose |
npoint = point + gaussian_noise success_off, touchloc = self.light_switch1(npoint, point_offset=np.matrix([-.15,0,0]).T, press_contact_pressure=300, | success_off, touchloc_bl = self.light_switch1(point, point_offset=np.matrix([-.15, 0, 0]).T, press_contact_pressure=300, | def gather_interest_point_dataset(self, point): gaussian = pr.Gaussian(np.matrix([0, 0, 0.]).T, np.matrix([[1., 0, 0], [0, .02**2, 0], [0, 0, .02**2]])) |
self.record_perceptual_data(touchloc) | self.behaviors.move_absolute((np.matrix([.15, .45, 1.3]).T, self.start_location[1]), stop='pressure_accel') self.record_perceptual_data(touchloc_bl) self.behaviors.move_absolute(self.start_location, stop='pressure_accel') success_on, touchloc_bl2 = self.light_switch1(point, point_offset=np.matrix([-.15,0,-.10]).T, pre... | def gather_interest_point_dataset(self, point): gaussian = pr.Gaussian(np.matrix([0, 0, 0.]).T, np.matrix([[1., 0, 0], [0, .02**2, 0], [0, 0, .02**2]])) |
success_on, touchloc = self.light_switch1(npoint, point_offset=np.matrix([-.15,0,-.10]).T, press_contact_pressure=300, move_back_distance=np.matrix([-0.005, 0, 0]).T, press_pressure=2500, press_distance=np.matrix([0,0,.1]).T, visual_change_thres=.03) | def gather_interest_point_dataset(self, point): gaussian = pr.Gaussian(np.matrix([0, 0, 0.]).T, np.matrix([[1., 0, 0], [0, .02**2, 0], [0, 0, .02**2]])) | |
Fz = _temp_val[2] | Fz = -_temp_val[2] | def binary_to_ft( raw_binary ): counts_per_force = 192 counts_per_torque = 10560 #raw_binary[0] = error value #TODO: this error is a checksum byte that we should watch for #corrupted transmission Fx = ord(raw_binary[1])*65536+ord(raw_binary[2])*256+ord(raw_binary[3]) Fy = ord(raw_binary[4])*65536+ord(raw_binary[5])*2... |
self.assertRaises(Exception, test_view('analytic_invoice')) | test_view('analytic_invoice') | def test0005views(self): ''' Test views. ''' self.assertRaises(Exception, test_view('analytic_invoice')) |
def encode(self): return struct.pack('>i', len(self.payload) + len(self.topic) + 2) + \ struct.pack('>h', len(self.topic)) + self.topic + self.payload | def encode_message(message): return struct.pack('>B', 0) + \ struct.pack('>i', binascii.crc32(message)) + \ message def encode_produce_request(topic, partition, messages): encoded = [encode_message(message) for message in messages] message_set = ''.join([struct.pack('>i', len(m)) + m for m in encoded]) data = stru... | def __init__(self, topic, payload): self.topic = topic self.payload = payload |
def __init__(self, topic, host, port): | def __init__(self, host, port): | def __init__(self, topic, host, port): self.REQUEST_KEY = 0 self.topic = topic self.connection = socket.socket() self.connection.connect((host, port)) |
self.topic = topic | def __init__(self, topic, host, port): self.REQUEST_KEY = 0 self.topic = topic self.connection = socket.socket() self.connection.connect((host, port)) | |
{"script": "traduisons.py", "icon_resources": [(1, "traduisons_icon.ico")] | {"script": "traduisons/traduisons.py", "icon_resources": [(1, "traduisons/data/traduisons_icon.ico")] | def get_hidden_imports(self): d = build_exe.py2exe.get_hidden_imports(self) d.setdefault('gtk._gtk', []).extend([ 'cairo', 'pango', 'pangocairo', 'atk']) return d |
echo = False | echo = True | def backgroundThread(f): echo = False if echo: print "backgroundThread definition start" def newfunc(*args, **kwargs): if echo: print "newfunc definition start" class bgThread(threading.Thread): def __init__(self, f, *args, **kwargs): if echo: print "bgThread Init Start" self.f = f threading.Thread.__init__(self) if ec... |
self.msg_LATEST = version.StrictVersion(urllib2.urlopen('http://traduisons.googlecode.com/svn-history/r93/trunk/LATEST-IS').read().strip()) | self.msg_LATEST = version.StrictVersion(urllib2.urlopen('http://traduisons.googlecode.com/svn/trunk/LATEST-IS').read().strip()) | def is_latest(self): try: self.msg_LATEST except AttributeError: self.msg_LATEST = version.StrictVersion(urllib2.urlopen('http://traduisons.googlecode.com/svn-history/r93/trunk/LATEST-IS').read().strip()) return msg_VERSION >= self.msg_LATEST |
gobject.idle_add(self.statusBar1.set_text, self.msg_MODAL) | self.modal_message(self.msg_MODAL) | def check_for_update(self): '''Update language list. Check the server for a new version of Traduisons and notify the user.''' self.update_languages() self.msg_LANGTIP = self.pretty_print_languages(0) gobject.idle_add(self.langbox.set_tooltip_text, self.msg_LANGTIP) if not self.is_latest(): self.msg_MODAL = 'Update Avai... |
def modal_message(self, msg = None): if msg is None: msg = self.msg_MODAL gobject.idle_add(self.statusBar1.set_text, msg) | def check_for_update(self): '''Update language list. Check the server for a new version of Traduisons and notify the user.''' self.update_languages() self.msg_LANGTIP = self.pretty_print_languages(0) gobject.idle_add(self.langbox.set_tooltip_text, self.msg_LANGTIP) if not self.is_latest(): self.msg_MODAL = 'Update Avai... | |
x = self.dictLang self.update_languages() for k in x: if not self.dictLang.has_key(k): print k, ': Unavailable' | def is_latest(self): try: self.msg_LATEST except AttributeError: self.msg_LATEST = version.StrictVersion(urllib2.urlopen('http://traduisons.googlecode.com/svn-history/r93/trunk/LATEST-IS').read().strip()) return msg_VERSION >= self.msg_LATEST | def __init__(self, fromLang = 'auto', toLang = 'en', start_text = ''): if not self.fromLang(fromLang): self.fromLang('auto') if not self.toLang(toLang): self.toLang('en') self._text = start_text x = self.dictLang self.update_languages() for k in x: if not self.dictLang.has_key(k): print k, ': Unavailable' |
def languages(self): | def pretty_print_languages(self, right_justify = True): | def languages(self): '''Return a string of pretty-printed, newline-delimited languages in the format Name : code''' l = [] width = max([len(x) for x in self.dictLang.keys()]) for item in sorted(self.dictLang.keys()): l.append(("%" + str(width) + 's' + ' : %s') % (item, self.dictLang[item])) return '\n'.join(l) |
width = max([len(x) for x in self.dictLang.keys()]) | width = 0 if right_justify: width = max([len(x) for x in self.dictLang.keys()]) | def languages(self): '''Return a string of pretty-printed, newline-delimited languages in the format Name : code''' l = [] width = max([len(x) for x in self.dictLang.keys()]) for item in sorted(self.dictLang.keys()): l.append(("%" + str(width) + 's' + ' : %s') % (item, self.dictLang[item])) return '\n'.join(l) |
import gtk; global gtk | import gtk, gobject; global gtk; global gobject gtk.gdk.threads_init() | def convertentity(m): if m.group(1)=='#': try: return chr(int(m.group(2))) except XValueError: return '&#%s;' % m.group(2) try: return htmlentitydefs.entitydefs[m.group(2)] except KeyError: return ('&%s;' % m.group(2)).decode('ISO-8859-1') |
msg_LANGTIP = "Language : symbol\n" for item in sorted(self.dictLang.keys()): msg_LANGTIP += '\n' + item + ' : ' + self.dictLang.get(item) self.tooltips = gtk.Tooltips() | self.msg_LANGTIP = self.pretty_print_languages(0) self.msg_MODAL = '' | def __init__(self, fromLang = 'auto', toLang = 'en'): |
self.window.connect("delete_event", lambda w, e: gtk.main_quit()) | self.window.connect("delete_event", lambda w, e: sys.exit()) | def __init__(self, fromLang = 'auto', toLang = 'en'): |
self.AccelGroup.connect_group(ord('Q'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_LOCKED, lambda w, x, y, z: gtk.main_quit()) | self.AccelGroup.connect_group(ord('Q'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_LOCKED, lambda w, x, y, z: sys.exit()) | def __init__(self, fromLang = 'auto', toLang = 'en'): |
self.tooltips.set_tip(self.langbox, msg_LANGTIP) | self.langbox.set_tooltip_text(self.msg_LANGTIP) | def __init__(self, fromLang = 'auto', toLang = 'en'): |
self.tooltips.set_tip(self.entry, msg_HELP) | self.entry.set_tooltip_text(msg_HELP) | def __init__(self, fromLang = 'auto', toLang = 'en'): |
elif 'EXIT' in result: gtk.main_quit() | elif 'EXIT' in result: gtk.main_quit() return self.modal_message('translating...') | def enter_callback(self, widget, data = None): '''Submit entrybox text for translation.''' |
self.statusBar1.set_text('translating...') | def enter_callback(self, widget, data = None): '''Submit entrybox text for translation.''' | |
self.statusBar1.set_text('') | self.modal_message() | def enter_callback(self, widget, data = None): '''Submit entrybox text for translation.''' |
self.clipboard = gtk.clipboard_get() | self.clipboard = clipboard_get() | def enter_callback(self, widget, data = None): '''Submit entrybox text for translation.''' |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.