def test_absolute_distance(self): q = Quaternion(scalar=0, vector=[1,0,0]) p = Quaternion(scalar=0, vector=[0,1,0]) self.assertEqual((q-p).norm, Quaternion.absolute_distance(q,p)) q = Quaternion(angle=pi/2, axis=[1,0,0]) p = Quaternion(angle=pi/2, axis=[0,1,0]) self.assertEqual((q-p).norm, Quaternion.absolute_distance(q,p)) q = Quaternion(scalar=0, vector=[1,0,0]) p = Quaternion(scalar=-1, vector=[0,-1,0]) self.assertEqual((q+p).norm, Quaternion.absolute_distance(q,p)) q = Quaternion(scalar=1, vector=[1,1,1]) p = Quaternion(scalar=-1, vector=[-1,-1,-1]) p._normalise() q._normalise() self.assertAlmostEqual(0, Quaternion.absolute_distance(q,p), places=8)
def test(rwdobj: DetailsForReward): """MOVE AS MUCH AS POSSIBLE""" dis_traveled = euclidean(rwdobj.new_obj_pos, rwdobj.init_obj_pos) or_traveled = Quaternion.absolute_distance(Quaternion(rwdobj.new_obj_or), Quaternion(rwdobj.init_obj_or)) grip_strength = np.round(np.sum(np.abs(rwdobj.tactile_state[-1])), 2) obj_fell = grip_strength < 0.004 * rwdobj.action_space if obj_fell: return rwdobj.extrinsic_reward, True # reward finish else: return dis_traveled + or_traveled, False
def objF(self, x): """ Blackbox optimization function, sums error relative to all transforms in marker buffer for both translation and rotation :param x: """ sum = 0 for pose in self.marker_buffer[self.optimize_id]: sum += np.sum(np.square(np.subtract(x[0:4],pose[0:4]))) x_quat = Quaternion(x[6], x[3], x[4], x[5]) pose_quat = Quaternion(pose[6], pose[3], pose[4], pose[5]) dist = Quaternion.absolute_distance(x_quat, pose_quat)/3.14 sum += dist*dist return sum
def stabilize_quat(mpu, t, dist): """Function that returns a stabilized quaternion.""" q0 = Quaternion((0, 0, 0, 0)) t0 = time.time() tmp_dist = 10000 while((time.time() - t0 < t) or tmp_dist > dist): try: mpu.read_value() rotate_vect = mpu.quaternion q1 = Quaternion(rotate_vect) tmp_dist = Quaternion.absolute_distance(q1, q0) q0 = q1 except Exception: continue g = mpu.read_gravity() return q1, g
def precond(self, state_str): state = State.create_from_serialized_string(state_str) robot_pos = state.get_values_as_vec([robot_pos_fqn]) robot_orn = np.array(state.get_values_as_vec([robot_orn_fqn])) block_pos = state.get_values_as_vec([block_pos_fqn]) delta_side = state.get_values_as_vec(["constants/block_width"])[0] / 2 #close to block side and also in right orientation robot_des_pos = np.array([ block_pos[0] + delta_side * np.sin(dir_to_rpy[self.sidenum][2]), block_pos[1], block_pos[2] + delta_side * np.cos(dir_to_rpy[self.sidenum][2]) ]) gripper_pos_close = np.linalg.norm(robot_des_pos - robot_pos) < 0.03 des_quat = quat_to_np(rpy_to_quat(np.array(dir_to_rpy[self.sidenum])), format="wxyz") orn_dist = Quaternion.absolute_distance(Quaternion(des_quat), Quaternion(robot_orn)) orn_close = orn_dist < 0.01 return gripper_pos_close and orn_close
def get_closest_ee_goals(self, shape_goal, shape_class=Rectangle, grasp_offset=0.055): #symmetry that minimizes the distance between shape_goal and the current ee pose. curr_quat = Quaternion(p.getLinkState(self.robot, self.grasp_joint)[1]) goal_quat = Quaternion(shape_goal[1]) syms = shape_class.grasp_symmetries() transformation_lib_quats = [ quaternion_about_axis(sym, (0, 0, 1)) for sym in syms ] sym_quats = [ Quaternion(np.hstack([lib_quat[-1], lib_quat[0:3]])) for lib_quat in transformation_lib_quats ] best_sym_idx = np.argmin([ Quaternion.absolute_distance( curr_quat, Quaternion(matrix=np.dot(sym_quat.rotation_matrix, goal_quat.rotation_matrix))) for sym_quat in sym_quats ]) best_sym = syms[best_sym_idx] #best_quat = Quaternion(quaternion_about_axis(best_sym, (0,0,1))).rotate(goal_quat) #assert(Quaternion.absolute_distance(curr_quat, best_quat) < 0.01) best_quat = curr_quat #hack until I can get the angle stuff working #self.grasp_offset = grasp_offset+self.block_height*0.5 grasp_translation = np.array([0, 0, self.grasp_offset]) ee_trans = grasp_translation + shape_goal[0] grasp_rot = np.dot(curr_quat.rotation_matrix, np.linalg.inv(best_quat.rotation_matrix)) grasp_quat = np.array( [1, 0, 0, 0] ) # hack until I can get the angle stuff working Quaternion(matrix=grasp_rot).elements grasp = (grasp_translation, grasp_quat) ee_pose = (ee_trans, best_quat.elements) return ee_pose, grasp
def goto_pose(self, des_quat, des_ee_trans, env_index, env_ptr, transformed_pt, max_t=None): pos_tol = 0.005 quat_tol = 1.5 self._frankas[env_index].set_ee_transform(env_ptr, env_index, self._franka_name, transformed_pt) if max_t is None: max_t = self.max_steps_per_movement for i in range(int(max_t)): self._scene.step() if i % 10: self.render(custom_draws=custom_draws) if i % 20: ee_pose = self._frankas[env_index].get_ee_transform( env_ptr, self._franka_name) np_pose = transform_to_np(ee_pose, format="wxyz") if np.linalg.norm(des_ee_trans - np_pose[:3] ) < pos_tol and Quaternion.absolute_distance( Quaternion( quat_to_np(des_quat, format="wxyz")), Quaternion(np_pose[3:])) < quat_tol: [(self._scene.step(), self.render(custom_draws=custom_draws)) for i in range(10)] break if i == max_t - 1: print( "COuld not reach pose in time, distance still {} after time {}" .format(np.linalg.norm(des_ee_trans - np_pose[:3]), i)) return i
Metric[name]['orientation gt'] = Metric[ opt.object]['orientation gt'] # evaluation if not opt.real_world: for name in Metric: if Metric[name]['location'] is None: Metric[name]['location error'] = 1000 Metric[name]['orientation error'] = 1000 else: Metric[name]['location error'] = np.linalg.norm( Metric[name]['location'] - Metric[name]['location gt']) q1 = Quaternion(Metric[name]['orientation']) q2 = Quaternion(Metric[name]['orientation gt']) Metric[name][ 'orientation error'] = Quaternion.absolute_distance( q1, q2) Names.append(img_name) Metrics.append(Metric) print(Metric) if not opt.headless: if cv2.waitKey(1) & 0xFF == ord('q'): break cv2.imshow('DOPE', np.array(out_img)[..., ::-1]) if opt.showbelief: # TODO remove the [0] for a for loop when multiple objects. cv2.imshow('DOPE BELIEFS', np.array(out_beliefs[0])[..., ::-1]) # print(img_name) cv2.imwrite(opt.outf + 'DOPE_BELIEFS_' + img_name, np.array(out_beliefs[0])[..., ::-1])
def get_R_degree_error(quaternion_1, quaternion_2): rad = Quaternion.absolute_distance(Quaternion(quaternion_1), Quaternion(quaternion_2)) return np.rad2deg(rad)
def _quatclose(orn1, orn2, atol): """ Indicate quaternion similarities. It takes into account the fact that q and -q encode the same rotation. """ q1 = Quaternion(orn1[3], *orn1[:3]) q2 = Quaternion(orn2[3], *orn2[:3]) return Quaternion.absolute_distance(q1, q2) < atol
def cameraCallback(depth_image_msg, rgb_image_msg): global frame_count, processed_frame_count, record, tracking_frame, relative_frame, tf_listener global color_images, depth_images, rgb_poses, intrinsics, prev_pose_rot, prev_pose_tran global tsdf_integration_data, live_integration, integration_done, mesh_pub if record: try: # Convert your ROS Image message to OpenCV2 # TODO: Generalize image type cv2_depth_img = bridge.imgmsg_to_cv2(depth_image_msg, "16UC1") cv2_rgb_img = bridge.imgmsg_to_cv2(rgb_image_msg, "bgr8") except CvBridgeError: print(e) return else: # Get camera intrinsic from camera info if frame_count == 0: camera_info = rospy.wait_for_message(camera_info_topic, CameraInfo) intrinsics = getIntrinsicsFromMsg(camera_info) sensor_data.append([ o3d.geometry.Image(cv2_depth_img), o3d.geometry.Image(cv2_rgb_img), rgb_image_msg.header.stamp ]) if (frame_count > 30): data = sensor_data.popleft() try: (rgb_t, rgb_r) = tf_listener.lookupTransform( relative_frame, tracking_frame, data[2]) except: return rgb_t = np.array(rgb_t) rgb_r = np.array(rgb_r) tran_dist = np.linalg.norm(rgb_t - prev_pose_tran) rot_dist = Quaternion.absolute_distance( Quaternion(prev_pose_rot), Quaternion(rgb_r)) # TODO: Testing if this is a good practice, min jump to accept data if (tran_dist > translation_distance) or (rot_dist > rotational_distance): prev_pose_tran = rgb_t prev_pose_rot = rgb_r rgb_pose = tf.transformations.quaternion_matrix(rgb_r) rgb_pose[0, 3] = rgb_t[0] rgb_pose[1, 3] = rgb_t[1] rgb_pose[2, 3] = rgb_t[2] depth_images.append(data[0]) color_images.append(data[1]) rgb_poses.append(rgb_pose) if live_integration: integration_done = False rgbd = o3d.geometry.RGBDImage.create_from_color_and_depth( data[1], data[0], depth_scale, depth_trunc, False) tsdf_volume.integrate(rgbd, intrinsics, np.linalg.inv(rgb_pose)) integration_done = True if processed_frame_count % 50 == 0: mesh = tsdf_volume.extract_triangle_mesh() mesh_msg = meshToRos(mesh) mesh_msg.header.stamp = rospy.get_rostime() mesh_msg.header.frame_id = relative_frame mesh_pub.publish(mesh_msg) else: tsdf_integration_data.append( [data[0], data[1], rgb_pose]) processed_frame_count += 1 frame_count += 1
def grapsPoseGen( self, targetPosition, objectOrientation): # position: x,y,z + objectOrientation: w,x,y,z planedOrientation = np.zeros([4]) positionInDatabase = (np.round(targetPosition, 2) * 100 + self.center).astype(int) [numSolution, solutionStartIndex ] = self.poseSolutionsIndexInSerialization[positionInDatabase[0], positionInDatabase[1], positionInDatabase[2], :] # if grasp object with orientation, the y axis of object aligned with major axis of the object if (np.abs(np.linalg.norm(objectOrientation) - 1) < 1e-1): # turn around the y axis of the object to select the best orientation for grasp step = 1 # degree angleLoss = 10000 for i in range(0, 360, step): with self.env: while True: # if not self.robot.CheckSelfCollision(): if True: T = matrixFromQuat( quatMult( objectOrientation, quatFromAxisAngle([0, 1, 0], i / 180.0 * 3.14)) ) # matrixFromQuat(np.array([w,x,y,z])) T[0:3, 3] = targetPosition # solutions = self.robotIkmodel.manip.FindIKSolutions(T,IkFilterOptions.CheckEnvCollisions) solutions = self.robotIkmodel.manip.FindIKSolutions( T, 0) if solutions is not None and len(solutions) > 0: for j in range(len(solutions)): tempLoss = np.array( [1, 1, 1, 1, 1, 1, 1]).dot( np.abs((solutions[j, :] - self.jointsCenter) / self.jointsRange)) if (np.sum(solutions[j, :] > self.jointsUpLimit) == 0 and np.sum(solutions[j, :] < self. jointsDownLimit) == 0 and tempLoss < angleLoss): angleLoss = tempLoss planedOrientation = quatMult( objectOrientation, quatFromAxisAngle([0, 1, 0], i / 180.0 * 3.14)) break # if not find the best grasp orientation along the y axis of the object, # then select an orientation closest to the object from the database if angleLoss > 9999: orientationLoss = -10000 yAxisOfObjectFromQuaterion = matrixFromQuat(objectOrientation)[ 0:3, 1] # w,x,y,z of list, tuple, numpy array for i in range(solutionStartIndex.astype(int), (solutionStartIndex + numSolution).astype(int), 1): with self.env: while True: # if not self.robot.CheckSelfCollision(): if True: T = matrixFromQuat( self.reachabilitySet[i, :] ) # matrixFromQuat(np.array([w,x,y,z])) T[0:3, 3] = targetPosition # solutions = self.robotIkmodel.manip.FindIKSolutions(T,IkFilterOptions.CheckEnvCollisions) solutions = self.robotIkmodel.manip.FindIKSolutions( T, 0) if solutions is not None and len( solutions) > 0: yAxisOfOrientationCandidate = matrixFromQuat( self.reachabilitySet[i, :])[0:3, 1] tempLoss = yAxisOfOrientationCandidate.dot( yAxisOfObjectFromQuaterion) if (tempLoss > orientationLoss): orientationLoss = tempLoss planedOrientation = self.reachabilitySet[ i, :] break # grasp ball without orientation else: mixLoss = 10000 for i in range(solutionStartIndex.astype(int), (solutionStartIndex + numSolution).astype(int), 1): with self.env: while True: # if not self.robot.CheckSelfCollision(): if True: T = matrixFromQuat(self.reachabilitySet[i, :]) T[0:3, 3] = targetPosition # solutions = self.robotIkmodel.manip.FindIKSolutions(T,IkFilterOptions.CheckEnvCollisions) solutions = self.robotIkmodel.manip.FindIKSolutions( T, 0) if solutions is not None and len(solutions) > 0: for j in range(len(solutions)): tempLoss = np.array( [1, 1, 1, 1, 1, 1, 1]).dot( np.abs((solutions[j, :] - self.jointsCenter) / self.jointsRange)) tempLoss += np.array([0, 1, 0]).dot( matrixFromQuat( self.reachabilitySet[i, :])[0:3, 2]) if (np.sum(solutions[j, :] > self.jointsUpLimit) == 0 and np.sum(solutions[j, :] < self. jointsDownLimit) == 0 and tempLoss < mixLoss): mixLoss = tempLoss planedOrientation = self.reachabilitySet[ i, :] break # calculate the grasp position with offset graspOffset = 0.02 # unit: m planedOrientationWithOffset = np.zeros([4]) planedJointsAngleWithOffset = np.zeros([7]) # grasp joints angle graspPosition = targetPosition + matrixFromQuat(planedOrientation)[ 0:3, 2] * graspOffset - matrixFromQuat(planedOrientation)[ 0:3, 0] * graspOffset self.graspPositionWithOffset = graspPosition positionInDatabase = (np.round(graspPosition, 2) * 100 + self.center).astype(int) [numSolution, solutionStartIndex ] = self.poseSolutionsIndexInSerialization[positionInDatabase[0], positionInDatabase[1], positionInDatabase[2], :] # if grasp object with orientation, the y axis of object aligned with major axis of the object if (np.abs(np.linalg.norm(objectOrientation) - 1) < 1e-1): # turn around the y axis of the object to select the best orientation for grasp step = 1 # degree angleLoss = 10000 for i in range(0, 360, step): with self.env: while True: # if not self.robot.CheckSelfCollision(): if True: T = matrixFromQuat( quatMult( objectOrientation, quatFromAxisAngle([0, 1, 0], i / 180.0 * 3.14)) ) # matrixFromQuat(np.array([w,x,y,z])) T[0:3, 3] = graspPosition # solutions = self.robotIkmodel.manip.FindIKSolutions(T,IkFilterOptions.CheckEnvCollisions) solutions = self.robotIkmodel.manip.FindIKSolutions( T, 0) if solutions is not None and len(solutions) > 0: for j in range(len(solutions)): tempLoss = np.array( [1, 1, 1, 1, 1, 1, 1]).dot( np.abs((solutions[j, :] - self.jointsCenter) / self.jointsRange)) if (np.sum(solutions[j, :] > self.jointsUpLimit) == 0 and np.sum(solutions[j, :] < self. jointsDownLimit) == 0 and tempLoss < angleLoss): angleLoss = tempLoss planedOrientationWithOffset = quatMult( objectOrientation, quatFromAxisAngle([0, 1, 0], i / 180.0 * 3.14)) planedJointsAngleWithOffset = solutions[ j, :] break # if not find the best grasp orientation along the y axis of the object, # then select an orientation closest to the object from the database if angleLoss > 9999: orientationLoss = -10000 yAxisOfObjectFromQuaterion = matrixFromQuat(objectOrientation)[ 0:3, 1] # w,x,y,z of list, tuple, numpy array for i in range(solutionStartIndex.astype(int), (solutionStartIndex + numSolution).astype(int), 1): with self.env: while True: # if not self.robot.CheckSelfCollision(): if True: T = matrixFromQuat( self.reachabilitySet[i, :] ) # matrixFromQuat(np.array([w,x,y,z])) T[0:3, 3] = targetPosition # solutions = self.robotIkmodel.manip.FindIKSolutions(T,IkFilterOptions.CheckEnvCollisions) solutions = self.robotIkmodel.manip.FindIKSolutions( T, 0) if solutions is not None and len( solutions) > 0: yAxisOfOrientationCandidate = matrixFromQuat( self.reachabilitySet[i, :])[0:3, 1] tempLoss = yAxisOfOrientationCandidate.dot( yAxisOfObjectFromQuaterion) if (tempLoss > orientationLoss): orientationLoss = tempLoss planedOrientationWithOffset = self.reachabilitySet[ i, :] angleLoss1 = 10000 for j in range(len(solutions)): tempLoss1 = np.array([ 1, 1, 1, 1, 1, 1, 1 ]).dot( np.abs((solutions[j, :] - self.jointsCenter) / self.jointsRange)) if (np.sum(solutions[j, :] > self.jointsUpLimit) == 0 and np.sum( solutions[j, :] < self. jointsDownLimit) == 0 and tempLoss1 < angleLoss1): angleLoss1 = tempLoss planedJointsAngleWithOffset = solutions[ j, :] break # grasp ball without orientation else: mixLoss = 10000 planedOrientationQuat = pyQuat(planedOrientation) for i in range(solutionStartIndex.astype(int), (solutionStartIndex + numSolution).astype(int), 1): with self.env: while True: # if not self.robot.CheckSelfCollision(): if True: T = matrixFromQuat(self.reachabilitySet[i, :]) T[0:3, 3] = graspPosition # solutions = self.robotIkmodel.manip.FindIKSolutions(T,IkFilterOptions.CheckEnvCollisions) solutions = self.robotIkmodel.manip.FindIKSolutions( T, 0) if solutions is not None and len(solutions) > 0: for j in range(len(solutions)): tempQuat = pyQuat( self.reachabilitySet[i, :]) tempLoss = pyQuat.absolute_distance( tempQuat, planedOrientationQuat) if (np.sum(solutions[j, :] > self.jointsUpLimit) == 0 and np.sum(solutions[j, :] < self. jointsDownLimit) == 0 and tempLoss < mixLoss): mixLoss = tempLoss planedOrientationWithOffset = self.reachabilitySet[ i, :] planedJointsAngleWithOffset = solutions[ j, :] break self.graspOrientation = planedOrientationWithOffset self.graspJointsAngle = planedJointsAngleWithOffset return planedOrientationWithOffset
def preGrasp(self, targetPose): # position: x,y,z + objectOrientation: w,x,y,z targetPosition = targetPose[0:3] objectOrientation = targetPose[3:7] calibOffSet = 0.12 # unit: m planedOrientation = self.grapsPoseGen(targetPosition, objectOrientation) T = matrixFromQuat(planedOrientation) if (np.abs(np.linalg.norm(objectOrientation) - 1) < 1e-1): calibPosition = self.graspPositionWithOffset + T[ 0:3, 2] * calibOffSet * 0.6 - T[ 0:3, 0] * calibOffSet * 0.6 # grasp object with orientation else: calibPosition = self.graspPositionWithOffset + T[ 0:3, 2] * calibOffSet # grasp ball positionInDatabase = (np.round(calibPosition, 2) * 100 + self.center).astype(int) [numSolution, solutionStartIndex ] = self.poseSolutionsIndexInSerialization[positionInDatabase[0], positionInDatabase[1], positionInDatabase[2], :] preGraspOrientation = np.zeros([1, 4]) preGraspOrientationLoss = 10000 preGraspAnglesLoss = 10000 planedOrientationQuat = pyQuat(planedOrientation) for i in range(solutionStartIndex.astype(int), (solutionStartIndex + numSolution).astype(int), 1): with self.env: while True: # if not self.robot.CheckSelfCollision(): if True: T = matrixFromQuat(self.reachabilitySet[ i, :]) # matrixFromQuat(np.array([w,x,y,z])) T[0:3, 3] = calibPosition # solutions = self.robotIkmodel.manip.FindIKSolutions(T,IkFilterOptions.CheckEnvCollisions) solutions = self.robotIkmodel.manip.FindIKSolutions( T, 0) if solutions is not None and len(solutions) > 0: calibOrientationQuat = pyQuat( self.reachabilitySet[i, :]) tempLoss = pyQuat.absolute_distance( planedOrientationQuat, calibOrientationQuat) if (tempLoss < preGraspOrientationLoss): preGraspOrientationLoss = tempLoss preGraspOrientation = self.reachabilitySet[ i, :] break with self.env: while True: # if not self.robot.CheckSelfCollision(): if True: T = matrixFromQuat(preGraspOrientation ) # matrixFromQuat(np.array([w,x,y,z])) T[0:3, 3] = calibPosition # solutions = self.robotIkmodel.manip.FindIKSolutions(T,IkFilterOptions.CheckEnvCollisions) solutions = self.robotIkmodel.manip.FindIKSolutions(T, 0) if solutions is not None and len(solutions) > 0: for j in range(len(solutions)): tempLoss = np.array([0, 0, 0, 0, 1, 1, 1]).dot( np.abs((solutions[j, :] - self.jointsCenter) / self.jointsRange)) if (np.sum(solutions[j, :] > self.jointsUpLimit) == 0 and np.sum( solutions[j, :] < self.jointsDownLimit) == 0 and tempLoss < preGraspAnglesLoss): preGraspAnglesLoss = tempLoss preGraspAngles = solutions[j, :] break self.preGraspJointsAngle = preGraspAngles tempAngle = self.currentJointError + self.preGraspJointsAngle if (np.sum(tempAngle > self.jointsUpLimit) == 0 and np.sum(tempAngle < self.jointsDownLimit) == 0): return self.currentJointError + self.preGraspJointsAngle else: print "compensation out of joint limit" return self.preGraspJointsAngle
def follow_traj(fa,path, cart_gain = 2000, z_cart_gain = 2000, rot_cart_gain = 300, expect_contact=False, pb_world=None, monitor_execution=True, traj_type = "joint", dt = 8): cart_poses = [] if monitor_execution: for pt in path: if traj_type != "cart": cart_pt = pb_world.fk_rigidtransform(pt) else: cart_pt = pt if in_region_with_modelfailure(cart_pt): #import ipdb; ipdb.set_trace() print("expected model failure") #return "expected_model_failure" for pt, i in zip(path, range(len(path))): if traj_type == "cart": new_pos = pt else: new_pos = pb_world.fk_rigidtransform(pt) cart_poses.append(new_pos) if traj_type == "cart": fa.goto_pose_with_cartesian_control(new_pos, cartesian_impedances=[cart_gain, cart_gain, z_cart_gain,rot_cart_gain, rot_cart_gain, rot_cart_gain]) #one of these but with impedance control? compliance comes from the matrix so I think that's good enough else: #print("Curr joints", np.round(fa.get_joints(),2)) #print("proposed joints", np.round(pt,2)) #input("Are these joints ok?") joints_list = np.array(pt).tolist() if not fa.is_joints_reachable(joints_list): print("Joints not reachable") import ipdb; ipdb.set_trace() else: fa.goto_joints(np.array(pt).tolist(), duration=dt) force = feelforce() model_deviation = False cart_to_sigma = lambda cart: np.exp(-0.00026255*cart-4.14340759) sigma_cart = cart_to_sigma(np.array([cart_gain, cart_gain, z_cart_gain])) sigma_cart = 0.008 rot_sigma = cart_to_sigma(rot_cart_gain) if monitor_execution: try: if (np.abs(fa.get_pose().translation-new_pos.translation) >1.96*sigma_cart).any(): model_deviation = True print("Farther than expected. Expected "+str(np.round(new_pos.translation,2))+" but got "+ str(np.round(fa.get_pose().translation,2))) if (Quaternion.absolute_distance(Quaternion(fa.get_pose().quaternion),Quaternion(new_pos.quaternion)) > 1.96*rot_sigma): model_deviation = True print("Farther than expected. Expected "+str(np.round(new_pos.quaternion,2))+" but got "+ str(np.round(fa.get_pose().quaternion,2))) except ValueError: input("fa.get_pose() failed. Continue?") if force < CONTACT_THRESHOLD and not expect_contact: print("unexpected contact") model_deviation = True elif force > CONTACT_THRESHOLD and expect_contact: print("expected contact") model_deviation = True if model_deviation and len(cart_poses) >= 2: new_bad_state = np.hstack([cart_poses[-2].translation,cart_poses[-2].quaternion]) if len(bad_model_states) ==0: bad_model_states = new_bad_state bad_model_states = np.vstack([bad_model_states, new_bad_state]) elif not model_deviation and len(cart_poses) >= 2: if len(good_model_states) == 0: new_good_state = (np.hstack([cart_poses[-2].translation,cart_poses[-2].quaternion])) good_model_states = np.vstack([good_model_states,new_good_state]) np.save("data/door_bad_model_states.npy", bad_model_states) np.save("data/door_good_model_states.npy", good_model_states) if model_deviation: print("Ending MB policy due to model deviation") return("model_failure") if monitor_execution: return "expected_good"
def execute(self, action): # Apply motor forces target_positions = [self.motor_limit[i][0] + action[i] * (self.motor_limit[i][1] - self.motor_limit[i][0]) for i in range(len(action))] #pb.setJointMotorControlArray(self.robotId, self.motors,controlMode=pb.POSITION_CONTROL, targetPositions = target_positions, forces=np.array(self.motor_power), physicsClientId = self.pybullet_client_ID) offset = 0 for joint_index in range(pb.getNumJoints(self.robotId, physicsClientId = self.pybullet_client_ID)): joint_data = pb.getJointInfo(self.robotId, joint_index, physicsClientId = self.pybullet_client_ID) if joint_data[2] == pb.JOINT_FIXED: offset += 1 continue pb.resetJointState(self.robotId, joint_index, target_positions[joint_index - offset], physicsClientId = self.pybullet_client_ID) # Step simulation twice # TODO : This is now the bottleneck #pb.stepSimulation(physicsClientId = self.pybullet_client_ID) #pb.stepSimulation(physicsClientId = self.pybullet_client_ID) self.cur_step += 2 if self.GUI: time.sleep(0.01) distance=5 yaw = 0 humanPos, humanOrn = pb.getBasePositionAndOrientation(self.robotId, physicsClientId = self.pybullet_client_ID) pb.resetDebugVisualizerCamera(distance,yaw,-20,humanPos, physicsClientId = self.pybullet_client_ID); # Observe state state = self.collect_observations() # Compute reward # Compute imitation reward weight_imitation = 1.0 reward_imitation = 0 # Determine current motion data frame work_frame = self.init_frame + self.cur_step frame_data = self.data[work_frame] #self.data[self.init_frame]# # Quaternion Difference angle_sum = 0 for (label_index, label) in enumerate(self.reward_links): jointState = pb.getJointState(self.robotId, label_index, physicsClientId = self.pybullet_client_ID) target_qwxyz = Quaternion(frame_data['qwxyz_'+label]) current_qwxyz = Quaternion(self.prev_jstate[4 + label_index*7:4 + label_index*7 +4]) #print(label, Quaternion.absolute_distance(target_qwxyz, current_qwxyz), '\n[' ,current_qwxyz, '], \n[', target_qwxyz, ']\n[',target_qwxyz / current_qwxyz,']') dist = Quaternion.absolute_distance(target_qwxyz, current_qwxyz) angle_sum += dist*dist reward_imitation += 0.65 * np.exp(-2 * angle_sum) # Angular Velocities ang_vel_sum = 0 ''' index_offset = 1 + 10*(1 + len(self.reward_links)) for (label_index, label) in enumerate(['root'] + self.reward_links): target_ang_vel = np.array(frame_data['ang_vel_'+ label]) current_ang_vel = np.array(state[index_offset + label_index*3]) dist = np.linalg.norm(target_ang_vel - current_ang_vel) ang_vel_sum += dist * dist #print('Angle:', angle_sum, np.exp(-2 * angle_sum)) # TODO: Fix this reward_imitation += 0.1 * np.exp(-0.1 * ang_vel_sum) #print('Vel :',ang_vel_sum, np.exp(-0.1 * ang_vel_sum)) # TODO : Optimize reward evaluation, this is fast # End effector matching ee_deviation = 0 for ee_label in self.end_effectors: ee_index = self.label2index[ee_label] if ee_index in self.link_states.keys(): ee_pos = self.link_states[ee_index] else: ee_pos = pb.getLinkState(self.robotId, ee_index, physicsClientId = self.pybullet_client_ID)[0] ee_target = frame_data['ee_' + ee_label] # TODO : Error: This is local #print(ee_label,'EE Pos:',ee_pos, ee_target) ee_diff = np.linalg.norm(ee_pos - ee_target) ee_deviation += ee_diff * ee_diff reward_imitation += 0.15 * np.exp(-40 * ee_deviation) # Center of Mass deviation # TODO : Optimize reward evaluation, this is very slow. Find a better way to determine CoM base_mass = self.link_masses['root'] total_mass = base_mass CoM = np.array(state[1:4]) * base_mass for link_label in self.reward_links: link_mass = self.link_masses[link_label] link_pos = self.link_states[self.label2index[link_label]]#pb.getLinkState(self.robotId, self.label2index[link_label])[0] # self.prev_jstate[8 + (link_index)*7:8 + (link_index)*7 + 3] CoM += np.array(link_pos) * link_mass total_mass += link_mass CoM = CoM / total_mass #CoM = pb.getBasePositionAndOrientation(self.robotId, physicsClientId = self.pybullet_client_ID)[0] CoM_deviation = np.linalg.norm(frame_data['CoM'] - CoM) reward_imitation += 0.1 * np.exp(-10 * CoM_deviation*CoM_deviation) ''' if False: print('ANG: ', angle_sum) print('CoM: ', CoM_deviation) print('EE: ', ee_deviation) #print('CoM :',CoM_deviation, np.exp(-10 * CoM_deviation*CoM_deviation)) #print(CoM, np.array(state[0:3]), self.data[work_frame]['CoM']) # Compute reward for achieving the goal weight_goal = 1 reward_goal = 0 # Nothing here for the static test # Compute final reward reward = weight_imitation * reward_imitation + weight_goal * reward_goal #print(weight_imitation * reward_imitation, weight_goal * reward_goal) # Return state, terminal bool and reward self.link_states = dict() # TODO : Implement early termination procedures #self.Early_Termination |= CoM_deviation > 1.0 reward = reward * (not self.Early_Termination) done = (self.cur_step + 2 >= self.n_steps) or (self.init_frame + self.cur_step + 2 >= self.nframes )# or Early_Termination return (state, done, reward)