CMatrix4:\n ...","def read_camera(self):\n _, frame = self.camera.read()\n return self.mirror(frame)","def find_start_pose(self):\n\n # Find start position\n y,x = [k for k,v in self.mp.items() if v == 94 or v == 60 \\\n or v == 62 or v == 118][0]\n\n\n # Assign orientation\n dy,dx, theta = 0,0, 0\n if self.mp[y,x] == ord('^'): theta = np.pi/2\n elif mp[y,x] == ord('<'): theta = -np.pi\n elif mp[y,x] == ord('>'): theta = 0\n else: theta = -np.pi/2\n\n return y, x, theta","def test_active_matrix_from_extrinsic_euler_zyz():\n assert_array_almost_equal(\n pr.active_matrix_from_extrinsic_roll_pitch_yaw([0.5 * np.pi, 0, 0]),\n np.array([\n [1, 0, 0],\n [0, 0, -1],\n [0, 1, 0]\n ])\n )\n assert_array_almost_equal(\n pr.active_matrix_from_extrinsic_roll_pitch_yaw(\n [0.5 * np.pi, 0, 0.5 * np.pi]),\n np.array([\n [0, 0, 1],\n [1, 0, 0],\n [0, 1, 0]\n ])\n )\n assert_array_almost_equal(\n pr.active_matrix_from_extrinsic_roll_pitch_yaw(\n [0.5 * np.pi, 0.5 * np.pi, 0]),\n np.array([\n [0, 1, 0],\n [0, 0, -1],\n [-1, 0, 0]\n ])\n )\n assert_array_almost_equal(\n pr.active_matrix_from_extrinsic_roll_pitch_yaw(\n [0.5 * np.pi, 0.5 * np.pi, 0.5 * np.pi]),\n np.array([\n [0, 0, 1],\n [0, 1, 0],\n [-1, 0, 0]\n ])\n )","def get_proj(self):\n relev, razim = np.pi * self.elev/180, np.pi * self.azim/180\n\n xmin, xmax = self.get_xlim3d()/self.pbaspect[0]\n ymin, ymax = self.get_ylim3d()/self.pbaspect[1]\n zmin, zmax = self.get_zlim3d()/self.pbaspect[2]\n\n # transform to uniform world coordinates 0-1.0,0-1.0,0-1.0 \n worldM = proj3d.world_transformation(xmin, xmax,\n ymin, ymax,\n zmin, zmax)\n\n # look into the middle of the new coordinates \n R = np.array([0.5, 0.5, 0.5])\n\n xp = R[0] + np.cos(razim) * np.cos(relev) * self.dist\n yp = R[1] + np.sin(razim) * np.cos(relev) * self.dist\n zp = R[2] + np.sin(relev) * self.dist\n E = np.array((xp, yp, zp))\n\n self.eye = E\n self.vvec = R - E\n self.vvec = self.vvec / proj3d.mod(self.vvec)\n\n if abs(relev) > np.pi/2:\n # upside down \n V = np.array((0, 0, -1))\n else:\n V = np.array((0, 0, 1))\n\n zfront, zback = -self.dist, self.dist\n\n viewM = proj3d.view_transformation(E, R, V)\n perspM = proj3d.persp_transformation(zfront, zback)\n M0 = np.dot(viewM, worldM)\n M = np.dot(perspM, M0)\n return M","def exteriorOrientationParameters(self):\n return self.__exteriorOrientationParameters","def get_camera_metadata(self):\n return self.camera.getHeight(), self.camera.getWidth(), 4 # channels","def get_coord(depth, pose, intrinsics_color_inv):\n img_height, img_width = depth.shape[0], depth.shape[1]\n mask = np.ones_like(depth)\n mask[depth==0] = 0\n mask = np.reshape(mask, (img_height, img_width,1))\n x = np.linspace(0, img_width-1, img_width)\n y = np.linspace(0, img_height-1, img_height)\n xx, yy = np.meshgrid(x, y)\n xx = np.reshape(xx, (1, -1))\n yy = np.reshape(yy, (1, -1))\n ones = np.ones_like(xx)\n pcoord = np.concatenate((xx, yy, ones), axis=0)\n depth = np.reshape(depth, (1, img_height*img_width))\n ccoord = np.dot(intrinsics_color_inv, pcoord) * depth\n ccoord = np.concatenate((ccoord, ones), axis=0)\n scoord = np.dot(pose, ccoord)\n scoord = np.swapaxes(scoord,0,1)\n scoord = scoord[:,0:3]\n scoord = np.reshape(scoord, (img_height, img_width,3))\n scoord = scoord * mask\n mask = np.reshape(mask, (img_height, img_width))\n return scoord, mask","def get_current_position(self) -> np.ndarray:\n pose_world = forward_kinematics(self.body, eef_link=self.DoF - 1)\n pose_rcm = self.pose_world2rcm(pose_world, 'matrix')\n return pose_rcm","def magnitude_orientation(gx, gy):\n \n magnitude = np.sqrt(gx**2 + gy**2)\n orientation = (np.arctan2(gy, gx) * 180 / np.pi) % 180\n \n return magnitude, orientation","def create_cam2world_matrix(forward_vector,\n origin,\n device=None):\n \"\"\"\"\"\"\n\n forward_vector = normalize_vecs(forward_vector)\n up_vector = torch.tensor([0, 1, 0], dtype=torch.float, device=device) \\\n .expand_as(forward_vector)\n\n left_vector = normalize_vecs(\n torch.cross(up_vector,\n forward_vector,\n dim=-1))\n\n up_vector = normalize_vecs(\n torch.cross(forward_vector,\n left_vector,\n dim=-1))\n\n rotation_matrix = torch.eye(4, device=device) \\\n .unsqueeze(0) \\\n .repeat(forward_vector.shape[0], 1, 1)\n rotation_matrix[:, :3, :3] = torch.stack(\n (-left_vector, up_vector, -forward_vector), axis=-1)\n\n translation_matrix = torch.eye(4, device=device) \\\n .unsqueeze(0) \\\n .repeat(forward_vector.shape[0], 1, 1)\n translation_matrix[:, :3, 3] = origin\n\n cam2world = translation_matrix @ rotation_matrix\n\n return cam2world","def get_x_y_z(drone, p, q, r):\n num_cameras = 2\n camera_constants = [0,math.pi/2]\n rads = np.zeros(num_cameras)\n phis = np.zeros(num_cameras)\n d = np.zeros(num_cameras)\n theta = np.zeros(num_cameras)\n Hs = np.zeros(num_cameras)\n s = 12\n HFOV = math.pi/4\n VFOV = 5*math.pi/36\n HPIX = 1280\n VPIX = 720\n #loop one, where we increment over camera number, and\n # get new information\n\n cent = calculate_centroid(p,q,r)\n for camera_num in range(num_cameras):\n\n A,B = find_a_and_b(p[camera_num],q[camera_num],r[camera_num],cent[camera_num])\n a = find_a(A,B)\n d_in = find_inner_d(a, s)\n angle_c = find_angle_c(a)\n alpha = find_alpha(HFOV, HPIX, A)\n w = find_w(angle_c, s)\n d_out = find_outer_d(w,alpha,a)\n pointy_front = is_point_front(r[camera_num],q[camera_num],p[camera_num],cent[camera_num])\n d[camera_num] = find_d(d_in,d_out,pointy_front)\n theta[camera_num] = find_theta(angle_c,A,B,camera_constants[camera_num])\n k = find_k(drone[camera_num], cent[camera_num])\n angle_k = find_angle_k(k, HFOV, HPIX)\n phi = find_phi(theta[camera_num], angle_k)\n rad = find_r(d[camera_num], angle_k)\n phis[camera_num] = phi\n rads[camera_num] = rad\n\n # end of first loop\n\n cosphis = np.cos(phis)\n sinphis = np.sin(phis)\n big_matrix = np.column_stack((cosphis,sinphis))\n points = np.zeros((int(num_cameras*(num_cameras-1)/2),2))\n i = 0\n for pair in itertools.combinations(range(num_cameras), 2):\n matrix_a = np.vstack((big_matrix[pair[0]],big_matrix[pair[1]]))\n vec_b = np.hstack((rads[pair[0]],rads[pair[1]]))\n point = np.linalg.solve(matrix_a, vec_b)\n points[i] = point\n i += 1\n drone_pos = np.mean(points,axis=0)\n\n # start of third loop\n for camera_num in range(num_cameras):\n d_prime = find_d_prime(d[camera_num], theta[camera_num], drone_pos)\n P,Q,M,N = find_P_Q_M_N(p[camera_num],q[camera_num],r[camera_num])\n h = find_h(d[camera_num],P,Q,M,N)\n angle_4 = find_angle_4(h,d[camera_num])\n Y = find_Y(drone[camera_num], cent[camera_num])\n angle_5 = find_angle_5(Y, VFOV, VPIX)\n angle_6 = angle_5 - angle_4\n h_prime = find_h_prime(d_prime, angle_6)\n Hs[camera_num] = h + h_prime\n drone_h = np.mean(H)\n return np.append(drone_pos,drone_h)"],"string":"[\n \"def get_camera_orientation(self):\\n\\n # Create the vector from the camera to the robot\\n vector_x = self.robot_x - self.camera_x\\n vector_y = self.robot_y - self.camera_y\\n vector_z = self.robot_z - self.camera_z\\n\\n # Calculate yaw and pitch from this vector\\n yaw = math.atan2(vector_y, vector_x)\\n pitch = -math.asin(vector_z)\\n\\n # Create the quaternion from the euler angles\\n self.quaternion = geometry_msgs.msg.Quaternion(\\n *tf_conversions.transformations.quaternion_from_euler(0, pitch, yaw))\",\n \"def get_extrinsic_matrix(pose):\\n batch_size, _ = pose.shape\\n rot = pose[:,:3]\\n trans = pose[:,3:]\\n\\n rot = transforms.euler_angles_to_matrix(rot,convention=\\\"XYZ\\\")\\n pose = torch.cat((rot,trans.view(batch_size, 3, 1)), -1)\\n\\n return pose\",\n \"def camera_matrix(e, p, t):\\n # Translates all points such that the camera is centered at the origin.\\n T = np.array([[1, 0, 0, -e[0]],\\n [0, 1, 0, -e[1]],\\n [0, 0, 1, -e[2]],\\n [0, 0, 0, 1]])\\n\\n # Set up orthonormal basis.\\n w = e - p\\n w = w / np.linalg.norm(w)\\n u = np.cross(t, w)\\n u = u / np.linalg.norm(u)\\n v = np.cross(w, u)\\n\\n # Rotate points such that camera is aligned with UVW-axes (g -> -z-axis).\\n R = np.array([[u[0], u[1], u[2], 0],\\n [v[0], v[1], v[2], 0],\\n [w[0], w[1], w[2], 0],\\n [ 0, 0, 0, 1]])\\n return R.dot(T)\",\n \"def getCameraMatrix(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def modelview_matrix(self):\\n camera = self.figure.scene.camera\\n return camera.view_transform_matrix.to_array().astype(np.float32)\",\n \"def camera_transformation_from_pose(azimutal, elevation):\\n azimutal, elevation = azimutal * 2. * np.pi / 360., elevation * 2. * np.pi / 360.\\n azimutal *= -1.\\n elevation *= -1.\\n r_y = np.array([[np.cos(elevation), 0, np.sin(elevation)],\\n [0, 1, 0],\\n [-np.sin(elevation), 0, np.cos(elevation)]])\\n r_z = np.array([[np.cos(azimutal), -np.sin(azimutal), 0],\\n [np.sin(azimutal), np.cos(azimutal), 0],\\n [0, 0, 1]])\\n r = r_z.dot(r_y)\\n # world_to_camera matrix, camera_to_world matrix\\n return r, np.linalg.inv(r)\",\n \"def get_transform_matrix(theta, phi = None, invert_rot = False, invert_focal = False):\\n\\n if phi is None:\\n phi = const.PHI_IDX * 10.0\\n\\n #extrinsic x intrinsic\\n camera_matrix = np.zeros((4, 4), dtype=np.float32)\\n\\n intrinsic_matrix = np.eye(4, dtype=np.float32)\\n extrinsic_matrix = np.eye(4, dtype=np.float32)\\n\\n sin_phi = np.sin(float(phi) / 180.0 * np.pi)\\n cos_phi = np.cos(float(phi) / 180.0 * np.pi)\\n sin_theta = np.sin(float(-theta) / 180.0 * np.pi)\\n cos_theta = np.cos(float(-theta) / 180.0 * np.pi)\\n\\n #theta rotation\\n rotation_azimuth = np.zeros((3, 3), dtype=np.float32)\\n rotation_azimuth[0, 0] = cos_theta\\n rotation_azimuth[2, 2] = cos_theta\\n rotation_azimuth[0, 2] = -sin_theta\\n rotation_azimuth[2, 0] = sin_theta\\n rotation_azimuth[1, 1] = 1.0\\n\\n #phi rotation\\n rotation_elevation = np.zeros((3, 3), dtype=np.float32)\\n rotation_elevation[0, 0] = cos_phi\\n rotation_elevation[0, 1] = sin_phi\\n rotation_elevation[1, 0] = -sin_phi\\n rotation_elevation[1, 1] = cos_phi\\n rotation_elevation[2, 2] = 1.0\\n\\n #rotate phi, then theta\\n rotation_matrix = np.matmul(rotation_azimuth, rotation_elevation)\\n if invert_rot:\\n rotation_matrix = np.linalg.inv(rotation_matrix)\\n\\n displacement = np.zeros((3, 1), dtype=np.float32)\\n displacement[0, 0] = const.DIST_TO_CAM\\n displacement = np.matmul(rotation_matrix, displacement)\\n\\n #assembling 4x4 from R + T\\n extrinsic_matrix[0:3, 0:3] = rotation_matrix\\n extrinsic_matrix[0:3, 3:4] = -displacement\\n\\n if invert_focal:\\n intrinsic_matrix[2, 2] = float(const.focal_length)\\n intrinsic_matrix[1, 1] = float(const.focal_length)\\n else:\\n intrinsic_matrix[2, 2] = 1.0 / float(const.focal_length)\\n intrinsic_matrix[1, 1] = 1.0 / float(const.focal_length)\\n\\n camera_matrix = np.matmul(extrinsic_matrix, intrinsic_matrix)\\n return camera_matrix\",\n \"def pose2mat(pose):\\n extrinsic = torch.eye(4)\\n extrinsic[:3, :] = pose[:, :4]\\n inv_extrinsic = torch.inverse(extrinsic)\\n extrinsic = torch.inverse(inv_extrinsic)\\n h, w, focal_length = pose[:, 4]\\n intrinsic = torch.Tensor([[focal_length, 0, w/2],\\n [0, focal_length, h/2],\\n [0, 0, 1]])\\n\\n return extrinsic, intrinsic\",\n \"def perspective_transform():\\n src = np.float32([(220,720), (1110, 720), (570, 470), (722, 470)]) # Manually get these numbers from plot\\n dst = np.float32([[320, 720], [920, 720], [320, 1], [920, 1]])\\n M = cv2.getPerspectiveTransform(src, dst)\\n Minv = cv2.getPerspectiveTransform(dst, src)\\n\\n return M, Minv\",\n \"def camera_matrix(self) -> TransformationMatrixType:\\n return numpy.matmul(\\n self.rotation_matrix(*self.rotation),\\n displacement_matrix(*-numpy.array(self.location)),\\n )\",\n \"def determine_rotation_matrix(self, origin, angle, scale):\\n # scaling will be ignored at this step\\n rotation_matrix = cv2.getRotationMatrix2D(origin, angle * 180 / np.pi, scale)\\n return rotation_matrix\",\n \"def get_matrix(transform):\\n\\n rotation = transform.rotation\\n location = transform.location\\n c_y = np.cos(np.radians(rotation.yaw))\\n s_y = np.sin(np.radians(rotation.yaw))\\n c_r = np.cos(np.radians(rotation.roll))\\n s_r = np.sin(np.radians(rotation.roll))\\n c_p = np.cos(np.radians(rotation.pitch))\\n s_p = np.sin(np.radians(rotation.pitch))\\n matrix = np.matrix(np.identity(4))\\n matrix[0, 3] = location.x\\n matrix[1, 3] = location.y\\n matrix[2, 3] = location.z\\n matrix[0, 0] = c_p * c_y\\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\\n matrix[1, 0] = s_y * c_p\\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\\n matrix[2, 0] = s_p\\n matrix[2, 1] = -c_p * s_r\\n matrix[2, 2] = c_p * c_r\\n\\n origin = np.array([location.x, location.y, location.z])\\n return matrix, origin\",\n \"def decompose_essential_matrix(E, x1, x2):\\n\\n # Fix left camera-matrix\\n Rl = np.eye(3)\\n tl = np.array([[0, 0, 0]]).T\\n Pl = np.concatenate((Rl, tl), axis=1)\\n\\n # TODO: Compute possible rotations and translations\\n \\n # s must be [1, 1, 0]\\n u, s, vh = np.linalg.svd(E)\\n E = u @ np.diag([1, 1, 0]) @ vh\\n u, s, vh = np.linalg.svd(E)\\n\\n w = np.array([[ 0, 1, 0], \\n [-1, 0, 0], \\n [ 0, 0, 1]]) \\n \\n z = np.array([[ 0, -1, 0], \\n [ 1, 0, 0],\\n [ 0, 0, 0]])\\n \\n R1 = u @ w.T @ vh\\n s1 = -u @ z @ u.T\\n R2 = u @ w @ vh\\n s2 = u @ z @ u.T\\n\\n t1 = np.array([[s1[2, 1]], \\n [s1[0, 2]],\\n [s1[1, 0]]])\\n \\n t2 = np.array([[s2[2, 1]], \\n [s2[0, 2]], \\n [s2[1, 0]]]) \\n\\n # Four possibilities\\n Pr = [np.concatenate((R1, t1), axis=1),\\n np.concatenate((R1, t2), axis=1),\\n np.concatenate((R2, t1), axis=1),\\n np.concatenate((R2, t2), axis=1)]\\n\\n # Compute reconstructions for all possible right camera-matrices\\n X3Ds = [infer_3d(x1[:, 0:1], x2[:, 0:1], Pl, x) for x in Pr]\\n\\n # Compute projections on image-planes and find when both cameras see point\\n test = [np.prod(np.hstack((Pl @ np.vstack((X3Ds[i], [[1]])), Pr[i] @ np.vstack((X3Ds[i], [[1]])))) > 0, 1) for i in\\n range(4)]\\n test = np.array(test)\\n idx = np.where(np.hstack((test[0, 2], test[1, 2], test[2, 2], test[3, 2])) > 0.)[0][0]\\n\\n # Choose correct matrix\\n Pr = Pr[idx]\\n\\n return Pl, Pr\",\n \"def get_camera_transform(self):\\r\\n if not self.pose:\\r\\n rospy.loginfo(\\\"no pose!\\\")\\r\\n return None\\r\\n if self.pose.header.frame_id != self.role_name:\\r\\n rospy.logwarn(\\\"Unsupported frame received. Supported {}, received {}\\\".format(\\r\\n self.role_name, self.pose.header.frame_id))\\r\\n return None\\r\\n sensor_location = carla.Location(x=self.pose.pose.position.x,\\r\\n y=-self.pose.pose.position.y,\\r\\n z=self.pose.pose.position.z)\\r\\n quaternion = (\\r\\n self.pose.pose.orientation.x,\\r\\n self.pose.pose.orientation.y,\\r\\n self.pose.pose.orientation.z,\\r\\n self.pose.pose.orientation.w\\r\\n )\\r\\n roll, pitch, yaw = euler_from_quaternion(quaternion)\\r\\n # rotate to CARLA\\r\\n sensor_rotation = carla.Rotation(pitch=math.degrees(roll)-90,\\r\\n roll=math.degrees(pitch),\\r\\n yaw=-math.degrees(yaw)-90)\\r\\n return carla.Transform(sensor_location, sensor_rotation)\",\n \"def computeMVP(self):\\n projMat = self.converterYUR\\n modelViewMat = self.transforMat.invertCompose(\\n Globals.render.getTransform(self.cameraNode)).getMat()\\n return UnalignedLMatrix4f(modelViewMat * projMat)\",\n \"def intrinsic_matrix_from_camera(w, h, fov):\\n (cx, cy), f = calc_focal_values(w, h, fov)\\n return np.array([[f, 0, cx], [0, f, cy], [0, 0, 1]])\",\n \"def projection_matrix(self):\\n scene = self.figure.scene\\n scene_size = tuple(scene.get_size())\\n aspect_ratio = float(scene_size[0]) / float(scene_size[1])\\n p = scene.camera.get_perspective_transform_matrix(\\n aspect_ratio, -1, 1).to_array().astype(np.float32)\\n return p\",\n \"def computeOrientation3D(object, P):\\n\\n # compute rotational matrix around yaw axis\\n R = [[np.cos(object.ry), 0, np.sin(object.ry)],\\n [0, 1, 0],\\n [-np.sin(object.ry), 0, np.cos(object.ry)]]\\n\\n # orientation in object coordinate system\\n orientation_3D = [[0.0, object.l],\\n [0.0, 0.0],\\n [0.0, 0.0]]\\n\\n # rotate and translate in camera coordinate system, project in image\\n orientation_3D = R * orientation_3D\\n orientation_3D[0, :] += object.t[0]\\n orientation_3D[1, :] += object.t[1]\\n orientation_3D[2, :] += object.t[2]\\n\\n # vector behind image plane?\\n if any(orientation_3D[2, :] < 0.1):\\n orientation_2D = []\\n else:\\n # project orientation into the image plane\\n orientation_2D = projectToImage(orientation_3D, P)\\n return orientation_2D\",\n \"def matrix(self):\\n return self._rotation\",\n \"def define_orientation_matrix(self):\\n from lmfit import Parameters\\n p = Parameters()\\n for i in range(3):\\n for j in range(3):\\n p.add('U%d%d' % (i, j), self.Umat[i, j])\\n self.init_p = self.Umat\\n return p\",\n \"def get_matrix(self, transform):\\r\\n\\r\\n rotation = transform.rotation\\r\\n location = transform.location\\r\\n c_y = np.cos(np.radians(rotation.yaw))\\r\\n s_y = np.sin(np.radians(rotation.yaw))\\r\\n c_r = np.cos(np.radians(rotation.roll))\\r\\n s_r = np.sin(np.radians(rotation.roll))\\r\\n c_p = np.cos(np.radians(rotation.pitch))\\r\\n s_p = np.sin(np.radians(rotation.pitch))\\r\\n matrix = np.matrix(np.identity(4))\\r\\n matrix[0, 3] = location.x\\r\\n matrix[1, 3] = location.y\\r\\n matrix[2, 3] = location.z\\r\\n matrix[0, 0] = c_p * c_y\\r\\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\\r\\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\\r\\n matrix[1, 0] = s_y * c_p\\r\\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\\r\\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\\r\\n matrix[2, 0] = s_p\\r\\n matrix[2, 1] = -c_p * s_r\\r\\n matrix[2, 2] = c_p * c_r\\r\\n return matrix\",\n \"def get_matrix(transform):\\n\\n rotation = transform.rotation\\n location = transform.location\\n c_y = np.cos(np.radians(rotation.yaw))\\n s_y = np.sin(np.radians(rotation.yaw))\\n c_r = np.cos(np.radians(rotation.roll))\\n s_r = np.sin(np.radians(rotation.roll))\\n c_p = np.cos(np.radians(rotation.pitch))\\n s_p = np.sin(np.radians(rotation.pitch))\\n matrix = np.matrix(np.identity(4))\\n matrix[0, 3] = location.x\\n matrix[1, 3] = location.y\\n matrix[2, 3] = location.z\\n matrix[0, 0] = c_p * c_y\\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\\n matrix[1, 0] = s_y * c_p\\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\\n matrix[2, 0] = s_p\\n matrix[2, 1] = -c_p * s_r\\n matrix[2, 2] = c_p * c_r\\n return matrix\",\n \"def get_matrix(transform):\\n\\n rotation = transform.rotation\\n location = transform.location\\n c_y = np.cos(np.radians(rotation.yaw))\\n s_y = np.sin(np.radians(rotation.yaw))\\n c_r = np.cos(np.radians(rotation.roll))\\n s_r = np.sin(np.radians(rotation.roll))\\n c_p = np.cos(np.radians(rotation.pitch))\\n s_p = np.sin(np.radians(rotation.pitch))\\n matrix = np.matrix(np.identity(4))\\n matrix[0, 3] = location.x\\n matrix[1, 3] = location.y\\n matrix[2, 3] = location.z\\n matrix[0, 0] = c_p * c_y\\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\\n matrix[1, 0] = s_y * c_p\\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\\n matrix[2, 0] = s_p\\n matrix[2, 1] = -c_p * s_r\\n matrix[2, 2] = c_p * c_r\\n return matrix\",\n \"def calc_transform(src_, dst_):\\n M_ = cv2.getPerspectiveTransform(src_, dst_)\\n Minv_ = cv2.getPerspectiveTransform(dst_, src_)\\n return M_, Minv_\",\n \"def __init__(self, before, after):\\r\\n self.M = cv2.getPerspectiveTransform(before, after)\\r\\n self.inverse_M = cv2.getPerspectiveTransform(after, before)\",\n \"def head_pose_points(image, rotation_vector, translation_vector, camera_matrix):\\n rear_size = 1\\n rear_depth = 0\\n front_size = image.shape[1]\\n front_depth = front_size*2\\n val = [rear_size, rear_depth, front_size, front_depth]\\n point_2d = get_2d_points(image, rotation_vector, translation_vector, camera_matrix, val)\\n y = (point_2d[5] + point_2d[8])//2\\n x = point_2d[2]\\n \\n return (x, y)\",\n \"def get_orientation_matrix(self, p):\\n for i in range(3):\\n for j in range(3):\\n self.Umat[i, j] = p['U%d%d' % (i, j)].value\",\n \"def __rotate_model(self):\\n self.__model_matrix = self.__get_rotation_matrix(\\n self.__face.position_cartesian,\\n (1 + self.__face.position[2]) * 0.5)\",\n \"def perspectiveNormalizationXform(self):\\n return np.array([[1.0/np.tan(self.view_angle_h), 0, 0, 0],\\n [0, 1.0/np.tan(self.view_angle_v), 0, 0],\\n [0, 0, (self.far + self.near)/(self.far - self.near),\\n 2*self.far*self.near/(self.far - self.near)],\\n [0, 0, -1, 0]])\",\n \"def _calculate_camera_pose(frame, K, d, corners, pattern_shape=(6, 4), grid_size=30): # noqa: E501\\n img = frame.copy()\\n axis = np.float32([[grid_size, 0, 0], [0, grid_size, 0],\\n [0, 0, -grid_size]]).reshape(-1, 3)*2\\n\\n objp = np.zeros((np.prod(pattern_shape), 3), np.float32)\\n objp[:, :2] = np.mgrid[0:pattern_shape[0],\\n 0:pattern_shape[1]].T.reshape(-1, 2) * grid_size\\n\\n _, rvecs, tvecs = cv2.solvePnP(objp, corners, K, d)\\n R, _ = cv2.Rodrigues(rvecs)\\n # project 3D points onto image plane\\n imgpts, _ = cv2.projectPoints(axis,\\n rvecs, tvecs,\\n K, d)\\n\\n canvas = computer_vision.draw_axis(img, corners, imgpts)\\n return R, tvecs, canvas\",\n \"def __init__(self, camera):\\n self.__camera = camera\\n self.__innerOrientationParameters = None\\n self.__isSolved = False\\n self.__exteriorOrientationParameters = np.array([0, 0, 0, 0, 0, 0], 'f')\\n self.__rotationMatrix = None\",\n \"def test_active_matrix_from_extrinsic_roll_pitch_yaw():\\n assert_array_almost_equal(\\n pr.active_matrix_from_extrinsic_euler_zyz([0.5 * np.pi, 0, 0]),\\n np.array([\\n [0, -1, 0],\\n [1, 0, 0],\\n [0, 0, 1]\\n ])\\n )\\n assert_array_almost_equal(\\n pr.active_matrix_from_extrinsic_euler_zyz(\\n [0.5 * np.pi, 0, 0.5 * np.pi]),\\n np.array([\\n [-1, 0, 0],\\n [0, -1, 0],\\n [0, 0, 1]\\n ])\\n )\\n assert_array_almost_equal(\\n pr.active_matrix_from_extrinsic_euler_zyz(\\n [0.5 * np.pi, 0.5 * np.pi, 0]),\\n np.array([\\n [0, 0, 1],\\n [1, 0, 0],\\n [0, 1, 0]\\n ])\\n )\\n assert_array_almost_equal(\\n pr.active_matrix_from_extrinsic_euler_zyz(\\n [0.5 * np.pi, 0.5 * np.pi, 0.5 * np.pi]),\\n np.array([\\n [-1, 0, 0],\\n [0, 0, 1],\\n [0, 1, 0]\\n ])\\n )\",\n \"def map_to_matrix(x, y):\\n x_pos = round(x * ((MATRIX_SIZE_X - 1)/(FRAME_W - 1)))\\n y_pos = round(y * ((MATRIX_SIZE_Y - 1)/(FRAME_H - 1)))\\n\\n x_pos = (MATRIX_SIZE_X - 1) - x_pos #invert x direction (left and right) to account for camera perspective\\n\\n return x_pos, y_pos\",\n \"def orientation(p, q, r):\\n val = (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y)\\n if val == 0:\\n return 0\\n elif val > 0:\\n return 1\\n else:\\n return 2\",\n \"def as_homogenous_transformation(self):\\n r3 = self.orientation.normalize().unit_quaternion_as_r3_rotation_matrix()\\n return matrix.sqr((r3[0],r3[1],r3[2],self.translation[0],\\n r3[3],r3[4],r3[5],self.translation[1],\\n r3[6],r3[7],r3[8],self.translation[2],\\n 0,0,0,1))\",\n \"def test_estimate_head_pose_with_use_orientation_mode(self):\\n\\n faceEngine = VLFaceEngine()\\n faceEngine.faceEngineProvider.faceDetV3Settings.useOrientationMode = 1\\n detector = faceEngine.createFaceDetector(DetectorType.FACE_DET_V3)\\n\\n images = [VLImage.load(filename=ROTATED0), VLImage.load(filename=ROTATED90)]\\n detections = detector.detect(images, detect68Landmarks=True)\\n angles0 = TestHeadPose.headPoseEstimator.estimate(detections[0][0].landmarks68)\\n angles90 = TestHeadPose.headPoseEstimator.estimate(detections[1][0].landmarks68)\\n\\n assert pytest.approx(angles90.pitch, abs=2) == angles0.pitch\\n assert pytest.approx(angles90.roll, abs=2) == angles0.roll\\n assert pytest.approx(angles90.yaw, abs=2) == angles0.yaw\",\n \"def orientation(cnt):\\n\\t(x,y), (MA, ma), angle = cv2.fitEllipse(cnt)\\n\\treturn angle\",\n \"def euler2mat(angle):\\n B = angle.size(0)\\n x, y, z = angle[:, 0], angle[:, 1], angle[:, 2]\\n\\n cosz = torch.cos(z)\\n sinz = torch.sin(z)\\n\\n zeros = z.detach() * 0\\n ones = zeros.detach() + 1\\n zmat = torch.stack([cosz, -sinz, zeros,\\n sinz, cosz, zeros,\\n zeros, zeros, ones], dim=1).view(B, 3, 3)\\n\\n cosy = torch.cos(y)\\n siny = torch.sin(y)\\n\\n ymat = torch.stack([cosy, zeros, siny,\\n zeros, ones, zeros,\\n -siny, zeros, cosy], dim=1).view(B, 3, 3)\\n\\n cosx = torch.cos(x)\\n sinx = torch.sin(x)\\n\\n xmat = torch.stack([ones, zeros, zeros,\\n zeros, cosx, -sinx,\\n zeros, sinx, cosx], dim=1).view(B, 3, 3)\\n\\n # rotMat = xmat.bmm(ymat).bmm(zmat)\\n # changed to match opencv and conversion euler->mat/mat->euler\\n rotMat = torch.bmm(zmat, torch.bmm(ymat, xmat))\\n\\n return rotMat\",\n \"def proj_to_velo(calib_data):\\n rect = calib_data[\\\"R0_rect\\\"].reshape(3, 3)\\n #to transform a point from Lidar framce to camera frame\\n #reshape the flat line with 12 elements to 3X4 matrix\\n velo_to_cam = calib_data[\\\"Tr_velo_to_cam\\\"].reshape(3, 4)\\n#print('velo2cam', velo_to_cam)\\n inv_rect = np.linalg.inv(rect)\\n #select all rows and only first three columns\\n#print('velo_to_cam[:, :3]', velo_to_cam[:, :3])\\n #select all rows and only first three columns\\n inv_velo_to_cam = np.linalg.pinv(velo_to_cam[:, :3])\\n return np.dot(inv_velo_to_cam, inv_rect)\",\n \"def GetRobotPos(self):\\n # read quaternion as the robot's current pose\\n orientation_q = self.odom.pose.pose.orientation\\n orientation_list = [orientation_q.x, orientation_q.y, orientation_q.z, orientation_q.w]\\n # transfer to Euler's angles, output angles are in the range (-pi, pi)\\n (roll, pitch, yaw) = euler_from_quaternion(orientation_list)\\n # # transfer to degrees\\n # roll = roll / np.pi * 180\\n # pitch = pitch / np.pi * 180\\n # yaw = yaw / np.pi * 180\\n return roll, pitch, yaw\",\n \"def _get_rotation_matrix(transform):\\n # caution: UE4 is using left-hand ortation order\\n roll = np.deg2rad(-transform.rotation.roll)\\n pitch = np.deg2rad(-transform.rotation.pitch)\\n yaw = np.deg2rad(transform.rotation.yaw)\\n sr, cr = np.sin(roll), np.cos(roll)\\n sp, cp = np.sin(pitch), np.cos(pitch)\\n sy, cy = np.sin(yaw), np.cos(yaw)\\n rotation_matrix = np.array([[cy * cp, -sy * sr + cy * sp * sr, cy * sp * cr + sy * sr],\\n [sy * cp, cy * sp * sr + cy * sr, -cy * sr + sy * sp * cr],\\n [-sp, cp * sr, cp * cr]])\\n return rotation_matrix\",\n \"def vrrotvec2mat(ax_ang):\\n\\n #file_dir = os.path.dirname(os.path.realpath(__file__))\\n #path_dir2 = file_dir + '/../geometry/'\\n #sys.path.append(path_dir2)\\n\\n if ax_ang.ndim == 1:\\n if np.size(ax_ang) == 5:\\n ax_ang = np.reshape(ax_ang, (5, 1))\\n msz = 1\\n elif np.size(ax_ang) == 4:\\n ax_ang = np.reshape(np.hstack((ax_ang, np.array([1]))), (5, 1))\\n msz = 1\\n else:\\n raise Exception('Wrong Input Type')\\n elif ax_ang.ndim == 2:\\n if np.shape(ax_ang)[0] == 5:\\n msz = np.shape(ax_ang)[1]\\n elif np.shape(ax_ang)[1] == 5:\\n ax_ang = ax_ang.transpose()\\n msz = np.shape(ax_ang)[1]\\n else:\\n raise Exception('Wrong Input Type')\\n else:\\n raise Exception('Wrong Input Type')\\n\\n direction = ax_ang[0:3, :]\\n angle = ax_ang[3, :]\\n\\n d = np.array(direction, dtype=np.float64)\\n d /= np.linalg.norm(d, axis=0)\\n x = d[0, :]\\n y = d[1, :]\\n z = d[2, :]\\n c = np.cos(angle)\\n s = np.sin(angle)\\n tc = 1 - c\\n\\n mt11 = tc*x*x + c\\n mt12 = tc*x*y - s*z\\n mt13 = tc*x*z + s*y\\n\\n mt21 = tc*x*y + s*z\\n mt22 = tc*y*y + c\\n mt23 = tc*y*z - s*x\\n\\n mt31 = tc*x*z - s*y\\n mt32 = tc*y*z + s*x\\n mt33 = tc*z*z + c\\n\\n mtx = np.column_stack((mt11, mt12, mt13, mt21, mt22, mt23, mt31, mt32, mt33))\\n\\n inds1 = np.where(ax_ang[4, :] == -1)\\n mtx[inds1, :] = -mtx[inds1, :]\\n\\n if msz == 1:\\n mtx = mtx.reshape(3, 3)\\n else:\\n mtx = mtx.reshape(msz, 3, 3)\\n\\n return mtx\",\n \"def _get_init_pose(self):\\n return self.init_pose_R, self.init_pose_t\",\n \"def rotation_matrix(self):\\n return self.affine_matrix[0:3][:, 0:3]\",\n \"def _get_camera_to_car_calibration(self, sensor): \\r\\n calibration = np.identity(3)\\r\\n calibration[0, 2] = sensor[\\\"width\\\"] / 2.0\\r\\n calibration[1, 2] = sensor[\\\"height\\\"] / 2.0\\r\\n calibration[0, 0] = calibration[1, 1] = sensor[\\\"width\\\"] / (2.0 * np.tan(sensor[\\\"fov\\\"] * np.pi / 360.0))\\r\\n return calibration\",\n \"def cameraToWorld(self, p):\\n result = self.camPos\\n result += p[2] * self.camZ # result is now in the middle of the view-plane\\n result += p[0] * self.camX # result is now in the middle-left of the view-plane\\n result += p[1] * self.camY # result is now the world-space equivalent of p\\n return result\",\n \"def ComputeInnerOrientation(self, imagePoints):\\n # implementing observation vectors\\n imagePoints = imagePoints.reshape(np.size(imagePoints), 1)\\n\\n fMarks = self.camera.fiducialMarks.reshape(np.size(self.camera.fiducialMarks), 1)\\n\\n n = int(len(imagePoints)) # number of observations\\n u = 6 # 6 orientation parameters\\n\\n A = np.zeros((n, u)) # A matrix (n,u)\\n\\n j = 0\\n for i in range(len(imagePoints)):\\n if i % 2 == 0:\\n A[i, 0] = 1;\\n A[i, 1] = 0;\\n A[i, 2] = fMarks[j];\\n A[i, 3] = fMarks[j + 1];\\n A[i, 4] = 0\\n A[i, 5] = 0\\n else:\\n A[i, 0] = 0;\\n A[i, 1] = 1;\\n A[i, 2] = 0;\\n A[i, 3] = 0;\\n A[i, 4] = fMarks[j];\\n A[i, 5] = fMarks[j + 1]\\n j += 2\\n\\n X = np.dot(la.inv(np.dot(np.transpose(A), A)), np.dot(np.transpose(A), imagePoints))\\n v = np.dot(A, X) - imagePoints\\n\\n adjustment_results = {\\\"params\\\": X, \\\"residuals\\\": v, \\\"N\\\": np.dot(np.transpose(A), A)}\\n\\n self.__innerOrientationParameters = X # updating the inner orientation params\\n\\n return adjustment_results\",\n \"def getMatrix(self, frame):\\n radian=np.radians(self.getValue(frame))\\n c=np.cos(radian)\\n s=np.sin(radian)\\n self.matrix[2, 2]=c\\n self.matrix[2, 0]=s\\n self.matrix[0, 2]=-s\\n self.matrix[0, 0]=c\\n return self.matrix\",\n \"def processOdom(self, msg):\\n self.x = msg.pose.pose.position.x\\n self.y = msg.pose.pose.position.y\\n self.z = 180 * (msg.pose.pose.orientation.z % 2)\\n print(self.z)\",\n \"def give_orientation(pose, orr_array):\\n pose.orientation.x = orr_array[0]\\n pose.orientation.y = orr_array[1]\\n pose.orientation.z = orr_array[2]\\n pose.orientation.w = orr_array[3]\",\n \"def get_pos_and_orientation(self):\\n pos, rot = p.getBasePositionAndOrientation(self.pybullet_id)\\n euler = p.getEulerFromQuaternion(rot)\\n return np.array(pos), euler[2]\",\n \"def get_pos_and_orientation(self):\\n pos, rot = p.getBasePositionAndOrientation(self.pybullet_id)\\n euler = p.getEulerFromQuaternion(rot)\\n return np.array(pos), euler[2]\",\n \"def get_pos_and_orientation(self):\\n pos, rot = p.getBasePositionAndOrientation(self.pybullet_id)\\n euler = p.getEulerFromQuaternion(rot)\\n return np.array(pos), euler[2]\",\n \"def get_projection_matrix(left, right, bottom, top):\\r\\n zNear = -25.0\\r\\n zFar = 25.0\\r\\n inv_z = 1.0 / (zFar - zNear)\\r\\n inv_y = 1.0 / (top - bottom)\\r\\n inv_x = 1.0 / (right - left)\\r\\n mat = [[(2.0 * inv_x), 0.0, 0.0, (-(right + left) * inv_x)],\\r\\n [0.0, (2.0 * inv_y), 0.0, (-(top + bottom) * inv_y)],\\r\\n [0.0, 0.0, (-2.0 * inv_z), (-(zFar + zNear) * inv_z)],\\r\\n [0.0, 0.0, 0.0, 1.0]]\\r\\n return mat\",\n \"def getMatrix(self, frame):\\n radian=np.radians(self.getValue(frame))\\n c=np.cos(radian)\\n s=np.sin(radian)\\n self.matrix[0, 0]=c\\n self.matrix[0, 1]=s\\n self.matrix[1, 0]=-s\\n self.matrix[1, 1]=c\\n return self.matrix\",\n \"def camera_transform(image):\\n img = np.zeros((image.shape[0], image.shape[1], 3))\\n for y in range(image.shape[0]):\\n for x in range(image.shape[1]):\\n img[y][x] = (x - 320) / 575.5 * image[y, x], (240 - y) / 575.5 * image[y, x], image[\\n y, x]\\n return img\",\n \"def rotation_matrix(yaw, pitch) -> TransformationMatrixType:\\n return rotation_matrix_yx(math.radians(yaw + 180), math.radians(pitch))\",\n \"def rotational_transform(self, X):\\n\\n # Unpack pose? could do something different here.\\n X_cam, Y_cam, Z_cam, azimuth_cam_deg, pitch_cam_deg, roll_cam_deg = self.p\\n\\n # Make X a set of homogeneous coors\\n X = np.vstack((X, np.ones(X.shape[1])))\\n\\n # Convert degrees to radians\\n azimuth_cam_rad = np.deg2rad(azimuth_cam_deg)\\n pitch_cam_rad = np.deg2rad(pitch_cam_deg)\\n roll_cam_rad = np.deg2rad(roll_cam_deg)\\n\\n translation_vec = [X_cam, Y_cam, Z_cam]\\n C = self.make_cam_mtx(azimuth_cam_rad, pitch_cam_rad, roll_cam_rad, translation_vec)\\n\\n return C @ X\",\n \"def get_rotation_angle(prev_image, curr_image, size_of_cropped_image):\\n max_value = np.amax(prev_image)\\n\\n if prev_image.dtype == 'float' and max_value <= 1:\\n prev_image = np.uint8(prev_image * 255)\\n curr_image = np.uint8(curr_image * 255)\\n\\n if prev_image.dtype == 'float' and max_value > 1:\\n prev_image = np.uint8(prev_image)\\n curr_image = np.uint8(curr_image)\\n\\n prev_image = cv.equalizeHist(prev_image)\\n curr_image = cv.equalizeHist(curr_image)\\n\\n # Initiate ORB detector\\n orb = cv.ORB_create(nfeatures=200)\\n\\n # find the keypoints and descriptors with ORB\\n kp1, des1 = orb.detectAndCompute(prev_image, None)\\n kp2, des2 = orb.detectAndCompute(curr_image, None)\\n\\n # do feature matching\\n bf = cv.BFMatcher(cv.NORM_HAMMING, crossCheck=True)\\n matches = bf.match(des1, des2)\\n matches = sorted(matches, key=lambda x: x.distance)\\n\\n # calculate perspective transform matrix\\n src_pts = np.float32([kp1[m.queryIdx].pt for m in matches]).reshape(-1, 1, 2)\\n dst_pts = np.float32([kp2[m.trainIdx].pt for m in matches]).reshape(-1, 1, 2)\\n transform_matrix, mask = cv.findHomography(src_pts, dst_pts, cv.RANSAC, 5.0)\\n\\n if transform_matrix is None:\\n transform_matrix, mask = cv.findHomography(src_pts, dst_pts, 0)\\n\\n if transform_matrix is None:\\n transform_matrix, mask = cv.findHomography(src_pts, dst_pts, 0)\\n\\n vector_along_x_axis_from_center = \\\\\\n np.float32([[size_of_cropped_image / 2, size_of_cropped_image / 2],\\n [size_of_cropped_image, size_of_cropped_image / 2]]).reshape(-1, 1, 2)\\n vector_transformed = cv.perspectiveTransform(vector_along_x_axis_from_center, transform_matrix)\\n\\n theta = - np.arctan2(vector_transformed[1, 0, 1] - vector_transformed[0, 0, 1],\\n vector_transformed[1, 0, 0] - vector_transformed[0, 0, 0]) * 180 / np.pi\\n # negative sign is to make the sign of the angle to correspond to one in a right-handed coordinate system\\n return theta\",\n \"def getMatrix(self, frame):\\n radian=np.radians(self.getValue(frame))\\n c=np.cos(radian)\\n s=np.sin(radian)\\n self.matrix[1, 1]=c\\n self.matrix[1, 2]=s\\n self.matrix[2, 1]=-s\\n self.matrix[2, 2]=c\\n return self.matrix\",\n \"def azizen(self):\\n # x0,y0 array pixel coordinates relative to cx,cy\\n# ndy0,ndx0=img.shape\\n ndy0=self.ndy0\\n ndx0=self.ndx0\\n x0,y0=np.meshgrid(np.linspace(0,ndx0-1,ndx0)-self.cx,np.linspace(0,ndy0-1,ndy0)-self.cy)\\n r0=np.sqrt(x0**2+y0**2)/self.pr0 # fractional radial distance from 0,0\\n# self.roi=np.s_[ystart:ystart+self.ny0,xstart:xstart+self.nx0]\\n # why not model the zenith angle dependence with polynomial directly\\n # rather than linear interpolation between roots.\\n roots=np.zeros(51)\\n rr=np.arange(51)/100.0\\n for i,ref in enumerate(rr):\\n roots[i]=np.real(np.roots([self.c3,0,self.c2,0,self.c1,-ref])[-1])\\n theta0 = np.interp(r0/2,rr,roots)\\n \\n phi0 = np.arctan2(x0,y0) - self.rot ####phi (i.e., azimuth) is reckoned with -pi corresponding to north, increasing clockwise, NOTE: pysolar use sub-standard definition\\n phi0 = phi0%(2*np.pi)\\n\\n #####correction for the tilt of the camera\\n k=np.array((np.sin(self.azm),np.cos(self.azm),0))\\n a=np.array([np.sin(theta0)*np.cos(phi0),np.sin(theta0)*np.sin(phi0),np.cos(theta0)]); \\n a = np.transpose(a,[1,2,0])\\n b=np.cos(self.beta)*a + np.sin(self.beta)*np.cross(k,a,axisb=2) \\\\\\n + np.reshape(np.outer(np.dot(a,k),k),(self.ndy0,self.ndx0,3))*(1-np.cos(self.beta))\\n theta0=np.arctan(np.sqrt(b[:,:,0]**2+b[:,:,1]**2)/b[:,:,2])\\n phi0=np.arctan2(b[:,:,1],b[:,:,0])%(2*np.pi)\\n# max_theta *= deg2rad \\n# valid0 = (theta0<max_theta) & (theta0>0); \\n# theta0[valid0]=np.nan;\\n self.theta0,self.phi0=theta0,phi0\",\n \"def transformation_matrix(self):\\n t = np.array([[0.0], [0.0], [0.0]])\\n Rt = np.hstack([self.rotation_matrix, t])\\n return np.vstack([Rt, np.array([0.0, 0.0, 0.0, 1.0])])\",\n \"def get_uv_coord(mode, camera, anno_xyz):\\r\\n\\tif camera == 'SK':\\r\\n\\t\\t# SK only have left hand. this is only for color image. Unable to translate kp to depth image.\\r\\n\\t\\tif mode == 'color':\\r\\n\\t\\t\\tuv_coord, _ = cv2.projectPoints(anno_xyz, I_SK.R_color, I_SK.T_color, I_SK.K_color, None)\\r\\n\\t\\telif mode == 'depth':\\r\\n\\t\\t\\tuv_coord, _ = cv2.projectPoints(anno_xyz, I_SK.R_depth, I_SK.T_depth, I_SK.K_depth, None)\\r\\n\\t\\telse:\\r\\n\\t\\t\\traise ValueError\\r\\n\\telif camera == 'BB':\\r\\n\\t\\tif mode == 'left':\\r\\n\\t\\t\\tuv_coord, _ = cv2.projectPoints(anno_xyz, I_BB.R_l, I_BB.T_l, I_BB.K, None)\\r\\n\\t\\telif mode == 'right':\\r\\n\\t\\t\\tuv_coord, _ = cv2.projectPoints(anno_xyz, I_BB.R_r, I_BB.T_r, I_BB.K, None)\\r\\n\\t\\telse:\\r\\n\\t\\t\\traise ValueError\\r\\n\\telse:\\r\\n\\t\\traise ValueError\\r\\n\\treturn np.reshape(uv_coord, (21, 2))\",\n \"def _calculate_homography(self):\\n src = np.array(self._metadata[:4])\\n\\n h_units = self._config.h_units\\n v_units = self._config.v_units\\n dst = np.array(\\n [(0, v_units), (h_units, v_units), (0, 0), (h_units, 0)])\\n\\n h_m, _ = cv2.findHomography(src, dst)\\n self.logger.info(f\\\"{self.id}: homography calculated\\\")\\n return h_m\",\n \"def orientation(self, p, q, r):\\n\\n val = (float(q.y - p.y) * (r.x - q.x)) - (float(q.x - p.x) * (r.y - q.y))\\n if (val > 0):\\n\\n # Clockwise orientation\\n return 1\\n elif (val < 0):\\n\\n # Counterclockwise orientation\\n return 2\\n else:\\n\\n # Colinear orientation\\n return 0\",\n \"def camera_location(azimuth, elevation, dist):\\n\\n phi = float(elevation)\\n theta = float(azimuth)\\n dist = float(dist)\\n\\n x = dist * math.cos(phi) * math.cos(theta)\\n y = dist * math.cos(phi) * math.sin(theta)\\n z = dist * math.sin(phi)\\n\\n return x, y, z\",\n \"def update_odometry(self, msg):\\n self.px = msg.pose.pose.position.x\\n \\tself.py = msg.pose.pose.position.y\\n \\tquat_orig = msg.pose.pose.orientation\\n \\tquat_list = [ quat_orig.x, quat_orig.y, quat_orig.z, quat_orig.w]\\n \\t#calculates roll, pitch, and yaw from quaternion\\n self.orient = msg.pose.pose.orientation\\n (roll , pitch , yaw) = euler_from_quaternion( quat_list )\\n \\tself.pth = yaw\",\n \"def restore_orientation_matrix(self):\\n self.Umat = self.init_p\",\n \"def test_pose(self):\\n t = self.t\\n \\n # Cyclic functions for orientation and position values\\n delta = math.sin(t) * 1000\\n alpha = math.cos(t) * math.pi * 2\\n \\n # Default values\\n x = 0\\n y = 0\\n z = 0\\n\\n pitch = 0\\n yaw = 0\\n roll = 0\\n \\n # assign values cyclically\\n if t % (math.pi * 12) < math.pi * 2:\\n x = delta\\n elif t % (math.pi * 12) < math.pi * 4:\\n y = delta\\n elif t % (math.pi * 12) < math.pi * 6:\\n z = delta\\n elif t % (math.pi * 12) < math.pi * 8:\\n pitch = alpha\\n elif t % (math.pi * 12) < math.pi * 10:\\n yaw = alpha\\n elif t % (math.pi * 12) < math.pi * 12:\\n roll = alpha\\n else:\\n # Reset counter\\n self.t = 0.0\\n \\n return ((x, y, z), (pitch, yaw, roll))\",\n \"def _make(self):\\n\\t\\tself.scene.camera = self.camera\\n\\t\\tself.camera.rotation_euler[0] = np.radians(np.random.randint(40, 100) +\\n\\t\\t np.random.random())\\n\\t\\tself.camera.rotation_euler[2] = np.radians(np.random.randint(0, 360) +\\n\\t\\t np.random.random())\\n\\t\\tprint([np.degrees(x) for x in self.camera.rotation_euler])\",\n \"def get_direction_matrix(self) -> int:\",\n \"def __init__(self, at=(0, 0, 0), eye=(0, 0, -0.1), lens=None,\\r\\n is_3d=True, scale=1.0):\\r\\n super(Camera, self).__init__()\\r\\n\\r\\n self.at = at\\r\\n self.start_eye = eye # for reset with different lens settings\\r\\n self.eye = [eye[0], eye[1], eye[2]]\\r\\n if lens == None:\\r\\n from pi3d.Display import Display\\r\\n lens = [Display.INSTANCE.near, Display.INSTANCE.far, Display.INSTANCE.fov,\\r\\n Display.INSTANCE.width / float(Display.INSTANCE.height)]\\r\\n self.lens = lens\\r\\n self.view = _LookAtMatrix(at, eye, [0, 1, 0])\\r\\n if is_3d:\\r\\n self.projection = _ProjectionMatrix(lens[0], lens[1], lens[2] / scale, lens[3])\\r\\n else:\\r\\n self.projection = _OrthographicMatrix(scale=scale)\\r\\n self.model_view = dot(self.view, self.projection)\\r\\n # Apply transform/rotation first, then shift into perspective space.\\r\\n self.mtrx = array(self.model_view, copy=True)\\r\\n # self.L_reflect = _LookAtMatrix(at,eye,[0,1,0],reflect=True)\\r\\n self.rtn = [0.0, 0.0, 0.0]\\r\\n\\r\\n self.was_moved = True\",\n \"def convert_pose_inverse_transform(pose):\\n translation = np.zeros((4,1))\\n translation[0] = -pose.position.x\\n translation[1] = -pose.position.y\\n translation[2] = -pose.position.z\\n translation[3] = 1.0\\n\\n rotation = (pose.orientation.x, pose.orientation.y, pose.orientation.z, pose.orientation.w)\\n euler_angle = tr.euler_from_quaternion(rotation)\\n rotation = np.transpose(tr.rotation_matrix(euler_angle[2], [0,0,1])) # the angle is a yaw\\n transformed_translation = rotation.dot(translation)\\n\\n translation = (transformed_translation[0], transformed_translation[1], transformed_translation[2])\\n rotation = tr.quaternion_from_matrix(rotation)\\n return (translation, rotation)\",\n \"def getDejaVuMatrix(self):\\n mtx = self.getRotMatrix((4, 4), transpose=None) # from Quaternion\\n mtx[3] = self.getTranslation()\\n mtx[:3, 3] = mtx[3, :3]\\n mtx[3, :3] = [0, 0, 0]\\n return mtx\",\n \"def __set_perspective(self):\\n\\n src = np.float32([[(.42 * self.img_shape[1],.65 * self.img_shape[0] ),\\n (.58 * self.img_shape[1], .65 * self.img_shape[0]),\\n (0 * self.img_shape[1],self.img_shape[0]),\\n (1 * self.img_shape[1], self.img_shape[0])]])\\n\\n dst = np.float32([[0,0],\\n [self.img_shape[1],0],\\n [0,self.img_shape[0]],\\n [self.img_shape[1],self.img_shape[0]]])\\n\\n self.M = cv2.getPerspectiveTransform(src, dst)\\n self.M_inv = cv2.getPerspectiveTransform(dst, src)\",\n \"def homogenous_transformation(x,y):\\n y_start = 0.3\\n y_stop = 1\\n src = np.float32([[0.45,y_start],[0.55, y_start],[0.1,y_stop],[0.9, y_stop]])\\n dst = np.float32([[0.45, y_start],[0.55, y_start],[0.45, y_stop],[0.55,y_stop]])\\n M_inv = cv2.getPerspectiveTransform(dst,src)\\n \\n ones = np.ones((1,len(y)))\\n coordinates = np.vstack((x, y, ones))\\n trans = np.matmul(M_inv, coordinates)\\n \\n x_vals = trans[0,:]/trans[2,:]\\n y_vals = trans[1,:]/trans[2,:]\\n return x_vals, y_vals\",\n \"def human_readable_pose2d(self, pose):\\n\\n\\t\\t# create a quaternion from the pose\\n\\t\\tquaternion = (\\n\\t\\tpose.orientation.x,\\n\\t\\tpose.orientation.y,\\n\\t\\tpose.orientation.z,\\n\\t\\tpose.orientation.w\\n\\t\\t)\\n\\n\\t\\t# convert quaternion rotation to euler rotation\\n\\t\\troll, pitch, yaw = euler_from_quaternion(quaternion)\\n\\n\\t\\tresult = (\\n\\t\\tpose.position.x, # x position\\n\\t\\tpose.position.y, # y position\\n\\t\\tyaw # theta angle\\n\\t\\t)\\n\\n\\t\\treturn result\",\n \"def test_estimate_head_pose_hight_level_with_use_orientation_mode(self):\\n\\n faceEngine = VLFaceEngine()\\n faceEngine.faceEngineProvider.faceDetV3Settings.useOrientationMode = 1\\n detector = VLFaceDetector(DetectorType.FACE_DET_V3, faceEngine)\\n\\n angles0 = detector.detectOne(VLImage.load(filename=ROTATED0)).headPose\\n angles90 = detector.detectOne(VLImage.load(filename=ROTATED90)).headPose\\n\\n assert pytest.approx(angles90.pitch, abs=2) == angles0.pitch\\n assert pytest.approx(angles90.roll, abs=2) == angles0.roll\\n assert pytest.approx(angles90.yaw, abs=2) == angles0.yaw\",\n \"def convert_pose_to_xy_and_theta(self, passed_stamped_pose):\\n # Convert to map coordinate frame from odom\\n pose = self.transform(passed_stamped_pose).pose # Apply current transform to given pose\\n\\n orientation_tuple = (pose.orientation.x,\\n pose.orientation.y,\\n pose.orientation.z,\\n pose.orientation.w)\\n angles = t.euler_from_quaternion(orientation_tuple)\\n\\n return (pose.position.x, pose.position.y, angles[2])\",\n \"def set_matrix(self):\\n theta1 = -90\\n theta2 = 105\\n theta3 = 180\\n\\n if self.number > 8:\\n theta2 = 75\\n\\n glMatrixMode(GL_MODELVIEW)\\n glPushMatrix()\\n glLoadIdentity()\\n glPushMatrix()\\n glRotatef(theta2, 0.0, 1.0, 0.0)\\n glRotatef(theta1, 1.0, 0.0, 0.0)\\n glRotatef(theta3, 0.0, 0.0, 1.0)\\n matrix = glGetDoublev(GL_MODELVIEW_MATRIX)\\n glPopMatrix()\\n glPopMatrix()\\n return matrix\",\n \"def _orientation(location, time='now'):\\n obstime = parse_time(time)\\n\\n # Define the frame where its Z axis is aligned with local zenith\\n local_frame = AltAz(obstime=obstime, location=location)\\n\\n return _sun_north_angle_to_z(local_frame)\",\n \"def reformat_pose_to_dict(self, now_pose):\\n # now_pose è un dict in particolare { pose : [ {position : [{x : value , y:value , z:value} ] } , {orientation : [] } }\\n # devo convertire i quaternioni in amgoli di eulero...estrarre i quaternioni da pose_now e convertirli in angoli RPY\\n\\n lato_corto_2 = 1.65 #1.45 # offset parcheggio\\n \\n #correggo gli offset x centrare le macchine nei parcheggi\\n\\n if abs(round(now_pose.position.x,2)) == 22.45:\\n if now_pose.position.x < 0 :\\n now_pose.position.x+=lato_corto_2\\n now_pose.position.y-=0.4\\n else :\\n now_pose.position.x-=lato_corto_2\\n now_pose.position.y+=0.4\\n \\n if abs(round(now_pose.position.y,2)) == 22.45:\\n if now_pose.position.y < 0 :\\n now_pose.position.y+=lato_corto_2\\n now_pose.position.x+=0.4\\n else :\\n now_pose.position.y-=lato_corto_2\\n now_pose.position.x-=0.4\\n\\n # correggo la z per renderla uguale all'asfalto che viene spownata nel mondo\\n\\n offset_asfalto = 0.3\\n\\n x = now_pose.position.x\\n y = now_pose.position.y\\n z = now_pose.position.z + offset_asfalto\\n\\n q1 = now_pose.orientation.x\\n q2 = now_pose.orientation.y\\n q3 = now_pose.orientation.z\\n q4 = now_pose.orientation.w\\n\\n\\n # converto i quaternioni in angoli di rulero RPY in radianti\\n orientation_list = [q1,q2,q3,q4]\\n\\n euler = euler_from_quaternion( orientation_list )\\n roll = euler[0]\\n pitch = euler[1]\\n yaw = round(euler[2],2) + np.pi\\n\\n\\n # creo la lista dei parametri che mi servono nel campo pose:[] del file .yaml\\n\\n lista_parametri = [x ,y ,z ,roll ,pitch ,yaw ]\\n\\n # creo un dict con tutti i campi di cui ho bisogno nel file .yaml\\n # settare le chiavi 'name' , ' type ' , 'package' , ' pose ' secondo le proprie necessità\\n # i due stili sono equivalenti : usare quello preferito\\n \\\"\\\"\\\"\\n {\\\"name\\\" : \\\"park1\\\" , \\n \\\"type\\\" : \\\"sdf\\\" , \\n \\\"package\\\" : \\\"object_spawner\\\" , \\n \\\"pose \\\":self.seq(lista_parametri) \\n }\\n \\n \\\"\\\"\\\"\\n lista_veicoli = ['macchina','pickup','ferrari','prius_hybrid','car_lexus','car_polo','car_volvo','car_golf']\\n num_veicoli = 1\\n\\n #modificare qui implementando una funzione randomica se si vogliono piu veicoli casuali spawnati\\n elemento_lista = {'name' : lista_veicoli[3],\\n 'type': 'sdf',\\n 'package': 'object_spawner',\\n 'pose': self.seq( x , y , z , roll , pitch , yaw)}\\n #\\\"\\\"\\\"\\n # elemento_lista = {'name' : 'ferrari',\\n # 'type': 'urdf',\\n # 'package': 'autopark',\\n # 'pose': self.seq( x , y , z , roll , pitch , yaw)}\\n\\n return elemento_lista\",\n \"def convert_pose_to_xy_and_theta(pose):\\n orientation_tuple = (pose.orientation.x, pose.orientation.y, pose.orientation.z, pose.orientation.w)\\n angles = euler_from_quaternion(orientation_tuple)\\n return pose.position.x, pose.position.y, angles[2]\",\n \"def matrix(self):\\n\\t\\t# apply yaw, then pitch, then roll\\n\\t\\treturn Matrix((\\n\\t\\t\\t(\\t1,\\t0,\\t\\t\\t\\t\\t\\t\\t0\\t\\t\\t\\t\\t\\t\\t),\\n\\t\\t\\t(\\t0,\\tmath.cos(self.roll.val),\\t-math.sin(self.roll.val)\\t),\\n\\t\\t\\t(\\t0,\\tmath.sin(self.roll.val),\\tmath.cos(self.roll.val)\\t\\t)\\n\\t\\t))* Matrix((\\n\\t\\t\\t(\\tmath.cos(self.pitch.val),\\t0,\\tmath.sin(self.pitch.val)\\t),\\n\\t\\t\\t(\\t0,\\t\\t\\t\\t\\t\\t\\t1,\\t0 \\t\\t\\t\\t\\t\\t\\t),\\n\\t\\t\\t(\\t-math.sin(self.pitch.val),\\t0,\\tmath.cos(self.pitch.val)\\t)\\n\\t\\t)) * Matrix((\\n\\t\\t\\t(\\tmath.cos(self.yaw.val),\\t-math.sin(self.yaw.val),\\t0\\t),\\n\\t\\t\\t(\\tmath.sin(self.yaw.val),\\tmath.cos(self.yaw.val),\\t\\t0\\t),\\n\\t\\t\\t(\\t0,\\t\\t\\t\\t\\t\\t0,\\t\\t\\t\\t\\t\\t\\t1\\t)\\n\\t\\t))\",\n \"def _cubelet_rotation_matrix(self, cubelet_meta_info, qpos_array):\\n euler_angles = qpos_array[cubelet_meta_info[\\\"euler_qpos\\\"]]\\n return rotation.euler2mat(euler_angles)\",\n \"def compute_right_camera_pose(left_camera_to_world, left_to_right):\\n left_world_to_camera = np.linalg.inv(left_camera_to_world)\\n right_world_to_camera = np.matmul(left_to_right, left_world_to_camera)\\n right_camera_to_world = np.linalg.inv(right_world_to_camera)\\n return right_camera_to_world\",\n \"def adjust_camera(self):\\n pose = deepcopy(self.data['poses']['marker']) # PoseStamped()\\n eye_pose = deepcopy(pose)\\n eye_pose.pose.position.x += 0.60\\n eye_pose.pose.position.z += 0.20\\n focus_pose = PoseStamped()\\n base_eye_pose = PoseStamped()\\n\\n try:\\n # Convert pose to base frame\\n pose.header.stamp = self.tfl. \\\\\\n getLatestCommonTime(self.params['world'], pose.header.frame_id)\\n focus_pose = self.tfl.transformPose(self.params['world'], pose)\\n except (TfE, LookupException, ConnectivityException):\\n Me.error_message(\\\"Error transforming pose \\\" + pose.header.frame_id)\\n\\n try:\\n # Convert pose to base frame\\n pose.header.stamp = self.tfl. \\\\\\n getLatestCommonTime(self.params['world'],\\n eye_pose.header.frame_id)\\n base_eye_pose = self.tfl.transformPose(self.params['world'],\\n eye_pose)\\n except (TfE, LookupException, ConnectivityException):\\n Me.error_message(\\\"Error transforming pose \\\" + pose.header.frame_id)\\n\\n cam_place = CameraPlacement()\\n cam_place.target_frame = self.params['world']\\n cam_place.time_from_start = Duration(1)\\n # Position of the camera relative to target_frame\\n cam_place.eye.header.frame_id = cam_place.target_frame\\n cam_place.eye.point = base_eye_pose.pose.position\\n # Target_frame-relative point for the focus\\n cam_place.focus.header.frame_id = cam_place.target_frame\\n cam_place.focus.point = focus_pose.pose.position\\n # Target_frame-relative vector that maps to \\\"up\\\" in the view plane.\\n cam_place.up.header.frame_id = cam_place.target_frame\\n cam_place.up.vector.x = 0\\n cam_place.up.vector.y = 0\\n cam_place.up.vector.z = 1\\n self.pub.publish(cam_place)\\n return\",\n \"def extract_calibration(self):\\n #TODO add function to check if the folder exists because opencv points to other error rather than saying it doesnt exist\\n cv_file = cv2.FileStorage(\\\"calib_images/calibration.yaml\\\", cv2.FILE_STORAGE_READ)\\n camera_matrix = cv_file.getNode(\\\"camera_matrix\\\").mat()\\n dist_matrix = cv_file.getNode(\\\"dist_coeff\\\").mat()\\n print(\\\"[INFO]: Extracted camera parameters.\\\")\\n cv_file.release()\\n return camera_matrix, dist_matrix\",\n \"def getTransposeMatrix(self) -> CMatrix4:\\n ...\",\n \"def read_camera(self):\\n _, frame = self.camera.read()\\n return self.mirror(frame)\",\n \"def find_start_pose(self):\\n\\n # Find start position\\n y,x = [k for k,v in self.mp.items() if v == 94 or v == 60 \\\\\\n or v == 62 or v == 118][0]\\n\\n\\n # Assign orientation\\n dy,dx, theta = 0,0, 0\\n if self.mp[y,x] == ord('^'): theta = np.pi/2\\n elif mp[y,x] == ord('<'): theta = -np.pi\\n elif mp[y,x] == ord('>'): theta = 0\\n else: theta = -np.pi/2\\n\\n return y, x, theta\",\n \"def test_active_matrix_from_extrinsic_euler_zyz():\\n assert_array_almost_equal(\\n pr.active_matrix_from_extrinsic_roll_pitch_yaw([0.5 * np.pi, 0, 0]),\\n np.array([\\n [1, 0, 0],\\n [0, 0, -1],\\n [0, 1, 0]\\n ])\\n )\\n assert_array_almost_equal(\\n pr.active_matrix_from_extrinsic_roll_pitch_yaw(\\n [0.5 * np.pi, 0, 0.5 * np.pi]),\\n np.array([\\n [0, 0, 1],\\n [1, 0, 0],\\n [0, 1, 0]\\n ])\\n )\\n assert_array_almost_equal(\\n pr.active_matrix_from_extrinsic_roll_pitch_yaw(\\n [0.5 * np.pi, 0.5 * np.pi, 0]),\\n np.array([\\n [0, 1, 0],\\n [0, 0, -1],\\n [-1, 0, 0]\\n ])\\n )\\n assert_array_almost_equal(\\n pr.active_matrix_from_extrinsic_roll_pitch_yaw(\\n [0.5 * np.pi, 0.5 * np.pi, 0.5 * np.pi]),\\n np.array([\\n [0, 0, 1],\\n [0, 1, 0],\\n [-1, 0, 0]\\n ])\\n )\",\n \"def get_proj(self):\\n relev, razim = np.pi * self.elev/180, np.pi * self.azim/180\\n\\n xmin, xmax = self.get_xlim3d()/self.pbaspect[0]\\n ymin, ymax = self.get_ylim3d()/self.pbaspect[1]\\n zmin, zmax = self.get_zlim3d()/self.pbaspect[2]\\n\\n # transform to uniform world coordinates 0-1.0,0-1.0,0-1.0 \\n worldM = proj3d.world_transformation(xmin, xmax,\\n ymin, ymax,\\n zmin, zmax)\\n\\n # look into the middle of the new coordinates \\n R = np.array([0.5, 0.5, 0.5])\\n\\n xp = R[0] + np.cos(razim) * np.cos(relev) * self.dist\\n yp = R[1] + np.sin(razim) * np.cos(relev) * self.dist\\n zp = R[2] + np.sin(relev) * self.dist\\n E = np.array((xp, yp, zp))\\n\\n self.eye = E\\n self.vvec = R - E\\n self.vvec = self.vvec / proj3d.mod(self.vvec)\\n\\n if abs(relev) > np.pi/2:\\n # upside down \\n V = np.array((0, 0, -1))\\n else:\\n V = np.array((0, 0, 1))\\n\\n zfront, zback = -self.dist, self.dist\\n\\n viewM = proj3d.view_transformation(E, R, V)\\n perspM = proj3d.persp_transformation(zfront, zback)\\n M0 = np.dot(viewM, worldM)\\n M = np.dot(perspM, M0)\\n return M\",\n \"def exteriorOrientationParameters(self):\\n return self.__exteriorOrientationParameters\",\n \"def get_camera_metadata(self):\\n return self.camera.getHeight(), self.camera.getWidth(), 4 # channels\",\n \"def get_coord(depth, pose, intrinsics_color_inv):\\n img_height, img_width = depth.shape[0], depth.shape[1]\\n mask = np.ones_like(depth)\\n mask[depth==0] = 0\\n mask = np.reshape(mask, (img_height, img_width,1))\\n x = np.linspace(0, img_width-1, img_width)\\n y = np.linspace(0, img_height-1, img_height)\\n xx, yy = np.meshgrid(x, y)\\n xx = np.reshape(xx, (1, -1))\\n yy = np.reshape(yy, (1, -1))\\n ones = np.ones_like(xx)\\n pcoord = np.concatenate((xx, yy, ones), axis=0)\\n depth = np.reshape(depth, (1, img_height*img_width))\\n ccoord = np.dot(intrinsics_color_inv, pcoord) * depth\\n ccoord = np.concatenate((ccoord, ones), axis=0)\\n scoord = np.dot(pose, ccoord)\\n scoord = np.swapaxes(scoord,0,1)\\n scoord = scoord[:,0:3]\\n scoord = np.reshape(scoord, (img_height, img_width,3))\\n scoord = scoord * mask\\n mask = np.reshape(mask, (img_height, img_width))\\n return scoord, mask\",\n \"def get_current_position(self) -> np.ndarray:\\n pose_world = forward_kinematics(self.body, eef_link=self.DoF - 1)\\n pose_rcm = self.pose_world2rcm(pose_world, 'matrix')\\n return pose_rcm\",\n \"def magnitude_orientation(gx, gy):\\n \\n magnitude = np.sqrt(gx**2 + gy**2)\\n orientation = (np.arctan2(gy, gx) * 180 / np.pi) % 180\\n \\n return magnitude, orientation\",\n \"def create_cam2world_matrix(forward_vector,\\n origin,\\n device=None):\\n \\\"\\\"\\\"\\\"\\\"\\\"\\n\\n forward_vector = normalize_vecs(forward_vector)\\n up_vector = torch.tensor([0, 1, 0], dtype=torch.float, device=device) \\\\\\n .expand_as(forward_vector)\\n\\n left_vector = normalize_vecs(\\n torch.cross(up_vector,\\n forward_vector,\\n dim=-1))\\n\\n up_vector = normalize_vecs(\\n torch.cross(forward_vector,\\n left_vector,\\n dim=-1))\\n\\n rotation_matrix = torch.eye(4, device=device) \\\\\\n .unsqueeze(0) \\\\\\n .repeat(forward_vector.shape[0], 1, 1)\\n rotation_matrix[:, :3, :3] = torch.stack(\\n (-left_vector, up_vector, -forward_vector), axis=-1)\\n\\n translation_matrix = torch.eye(4, device=device) \\\\\\n .unsqueeze(0) \\\\\\n .repeat(forward_vector.shape[0], 1, 1)\\n translation_matrix[:, :3, 3] = origin\\n\\n cam2world = translation_matrix @ rotation_matrix\\n\\n return cam2world\",\n \"def get_x_y_z(drone, p, q, r):\\n num_cameras = 2\\n camera_constants = [0,math.pi/2]\\n rads = np.zeros(num_cameras)\\n phis = np.zeros(num_cameras)\\n d = np.zeros(num_cameras)\\n theta = np.zeros(num_cameras)\\n Hs = np.zeros(num_cameras)\\n s = 12\\n HFOV = math.pi/4\\n VFOV = 5*math.pi/36\\n HPIX = 1280\\n VPIX = 720\\n #loop one, where we increment over camera number, and\\n # get new information\\n\\n cent = calculate_centroid(p,q,r)\\n for camera_num in range(num_cameras):\\n\\n A,B = find_a_and_b(p[camera_num],q[camera_num],r[camera_num],cent[camera_num])\\n a = find_a(A,B)\\n d_in = find_inner_d(a, s)\\n angle_c = find_angle_c(a)\\n alpha = find_alpha(HFOV, HPIX, A)\\n w = find_w(angle_c, s)\\n d_out = find_outer_d(w,alpha,a)\\n pointy_front = is_point_front(r[camera_num],q[camera_num],p[camera_num],cent[camera_num])\\n d[camera_num] = find_d(d_in,d_out,pointy_front)\\n theta[camera_num] = find_theta(angle_c,A,B,camera_constants[camera_num])\\n k = find_k(drone[camera_num], cent[camera_num])\\n angle_k = find_angle_k(k, HFOV, HPIX)\\n phi = find_phi(theta[camera_num], angle_k)\\n rad = find_r(d[camera_num], angle_k)\\n phis[camera_num] = phi\\n rads[camera_num] = rad\\n\\n # end of first loop\\n\\n cosphis = np.cos(phis)\\n sinphis = np.sin(phis)\\n big_matrix = np.column_stack((cosphis,sinphis))\\n points = np.zeros((int(num_cameras*(num_cameras-1)/2),2))\\n i = 0\\n for pair in itertools.combinations(range(num_cameras), 2):\\n matrix_a = np.vstack((big_matrix[pair[0]],big_matrix[pair[1]]))\\n vec_b = np.hstack((rads[pair[0]],rads[pair[1]]))\\n point = np.linalg.solve(matrix_a, vec_b)\\n points[i] = point\\n i += 1\\n drone_pos = np.mean(points,axis=0)\\n\\n # start of third loop\\n for camera_num in range(num_cameras):\\n d_prime = find_d_prime(d[camera_num], theta[camera_num], drone_pos)\\n P,Q,M,N = find_P_Q_M_N(p[camera_num],q[camera_num],r[camera_num])\\n h = find_h(d[camera_num],P,Q,M,N)\\n angle_4 = find_angle_4(h,d[camera_num])\\n Y = find_Y(drone[camera_num], cent[camera_num])\\n angle_5 = find_angle_5(Y, VFOV, VPIX)\\n angle_6 = angle_5 - angle_4\\n h_prime = find_h_prime(d_prime, angle_6)\\n Hs[camera_num] = h + h_prime\\n drone_h = np.mean(H)\\n return np.append(drone_pos,drone_h)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6524759","0.64992476","0.6400119","0.62868214","0.6233258","0.62323457","0.6178379","0.6016908","0.6012133","0.60015947","0.5997646","0.59892434","0.5961536","0.5942139","0.59395564","0.5925271","0.5909638","0.58591086","0.58126867","0.581134","0.5802404","0.5793011","0.5793011","0.5782746","0.5780559","0.577595","0.5741405","0.57348615","0.5727813","0.5678761","0.56739557","0.56732994","0.56709313","0.5644285","0.56363326","0.5630813","0.562723","0.5618931","0.5614829","0.56064165","0.56044763","0.56002766","0.5599191","0.5593354","0.5588049","0.55827403","0.55637366","0.5556181","0.5550753","0.5546361","0.5531557","0.5531557","0.5531557","0.55178195","0.55095774","0.5504455","0.55017334","0.5501311","0.55008453","0.5496078","0.5488816","0.5483579","0.5478765","0.54749095","0.54741","0.546547","0.54635227","0.5456508","0.54564357","0.54535115","0.5436113","0.5427847","0.5427393","0.54232115","0.54132503","0.5410755","0.5409979","0.5408566","0.539943","0.5393533","0.5390372","0.53890365","0.53822285","0.53795594","0.53770196","0.5374839","0.5370888","0.5360099","0.53508556","0.5345568","0.5336427","0.5333004","0.53304064","0.53297186","0.53235096","0.532338","0.5321936","0.5319187","0.5318664","0.53148115"],"string":"[\n \"0.6524759\",\n \"0.64992476\",\n \"0.6400119\",\n \"0.62868214\",\n \"0.6233258\",\n \"0.62323457\",\n \"0.6178379\",\n \"0.6016908\",\n \"0.6012133\",\n \"0.60015947\",\n \"0.5997646\",\n \"0.59892434\",\n \"0.5961536\",\n \"0.5942139\",\n \"0.59395564\",\n \"0.5925271\",\n \"0.5909638\",\n \"0.58591086\",\n \"0.58126867\",\n \"0.581134\",\n \"0.5802404\",\n \"0.5793011\",\n \"0.5793011\",\n \"0.5782746\",\n \"0.5780559\",\n \"0.577595\",\n \"0.5741405\",\n \"0.57348615\",\n \"0.5727813\",\n \"0.5678761\",\n \"0.56739557\",\n \"0.56732994\",\n \"0.56709313\",\n \"0.5644285\",\n \"0.56363326\",\n \"0.5630813\",\n \"0.562723\",\n \"0.5618931\",\n \"0.5614829\",\n \"0.56064165\",\n \"0.56044763\",\n \"0.56002766\",\n \"0.5599191\",\n \"0.5593354\",\n \"0.5588049\",\n \"0.55827403\",\n \"0.55637366\",\n \"0.5556181\",\n \"0.5550753\",\n \"0.5546361\",\n \"0.5531557\",\n \"0.5531557\",\n \"0.5531557\",\n \"0.55178195\",\n \"0.55095774\",\n \"0.5504455\",\n \"0.55017334\",\n \"0.5501311\",\n \"0.55008453\",\n \"0.5496078\",\n \"0.5488816\",\n \"0.5483579\",\n \"0.5478765\",\n \"0.54749095\",\n \"0.54741\",\n \"0.546547\",\n \"0.54635227\",\n \"0.5456508\",\n \"0.54564357\",\n \"0.54535115\",\n \"0.5436113\",\n \"0.5427847\",\n \"0.5427393\",\n \"0.54232115\",\n \"0.54132503\",\n \"0.5410755\",\n \"0.5409979\",\n \"0.5408566\",\n \"0.539943\",\n \"0.5393533\",\n \"0.5390372\",\n \"0.53890365\",\n \"0.53822285\",\n \"0.53795594\",\n \"0.53770196\",\n \"0.5374839\",\n \"0.5370888\",\n \"0.5360099\",\n \"0.53508556\",\n \"0.5345568\",\n \"0.5336427\",\n \"0.5333004\",\n \"0.53304064\",\n \"0.53297186\",\n \"0.53235096\",\n \"0.532338\",\n \"0.5321936\",\n \"0.5319187\",\n \"0.5318664\",\n \"0.53148115\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7063537"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":395,"cells":{"query":{"kind":"string","value":"This function returns the extrinsic parameter matrix"},"document":{"kind":"string","value":"def getExtrinsicParameter(K, R, C):\n t = np.dot(-R, C)\n homogeneous_matrix = np.hstack((R.reshape(3, 3), t))\n extrinsic_parameter = np.dot(K, homogeneous_matrix)\n return extrinsic_parameter"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_intrinsic_mat(params):\n return np.asarray(\n [\n [params[0], 0.0, params[1]],\n [0.0, params[2], params[3]],\n [0.0, 0.0, 1.0],\n ]\n )","def get_extrinsic_matrix(pose):\n batch_size, _ = pose.shape\n rot = pose[:,:3]\n trans = pose[:,3:]\n\n rot = transforms.euler_angles_to_matrix(rot,convention=\"XYZ\")\n pose = torch.cat((rot,trans.view(batch_size, 3, 1)), -1)\n\n return pose","def extrinsic(self):\n return self._extrinsic","def matrix_param(self):\n return self.__matrix_param","def getParameters(self):\n params = []\n for m in [self.ix, self.ih, self.fx, self.fh, self.ox, self.oh, self.ux, self.uh]:\n # we do not get param of output module\n l = list(m.parameters())\n params.extend(l)\n\n one_dim = [p.view(p.numel()) for p in params]\n params = F.torch.cat(one_dim)\n return params","def getParameters(self):\n params = []\n for m in [self.ix, self.ih, self.fx, self.fh, self.ox, self.oh, self.ux, self.uh]:\n # we do not get param of output module\n l = list(m.parameters())\n params.extend(l)\n\n one_dim = [p.view(p.numel()) for p in params]\n params = F.torch.cat(one_dim)\n return params","def get_params(self) -> np.array:\n pass","def getMatrix(self) -> CMatrix4:\n ...","def _get_params(self):\r\n x = np.hstack((self.X.flatten(), self.X_variance.flatten(), SparseGP._get_params(self)))\r\n return x","def get_parameters(self):\n return self.sess.run(self.A_symm)","def params(self):\n return {'out_dim': self.out_dim,\n 'act_fn': self.act_fn,\n 'use_bias': self.use_bias,\n 'idx': self.idx}","def get_params_array(self):\n return np.array(self.W), np.array(self.b)","def get_model_params(self):\n\n results = self._model.fit()\n model_params = np.expand_dims(results.params.as_matrix(), 1)\n return model_params","def matrix(self):\n return self._matrix(*self.parameters)","def M(self):\n return _hypre.HypreParMatrix_M(self)","def get_design_matrix(x):\n\tF = np.ones((10, 1))\n\tF = np.hstack((F, x))\n\n\treturn F","def _get_params(self):\r\n return np.hstack((self.k1._get_params(), self.k2._get_params()))","def _get_params(self):\r\n return np.hstack((self.k1._get_params(), self.k2._get_params()))","def pack_params(K, k, extrinsic_matrices):\n packed_params = []\n\n # Flatten intrinsics\n alpha, beta, gamma, u_c, v_c = K[0,0], K[1,1], K[0,1], K[0,2], K[1,2]\n k1, k2, k3 ,p1, p2 = k\n\n a = [alpha, beta, gamma, u_c, v_c,k1, k2, k3, p1, p2 ]\n\n packed_params.extend(a)\n\n # Flattened extrinsics\n for E in extrinsic_matrices:\n # Convert extrinsics to flattened Rodrigues representation\n R = E[:3, :3]\n t = E[:, 3]\n\n rodrigues = cv2.Rodrigues(R)[0]\n\n rho_x, rho_y, rho_z = rodrigues\n t_x, t_y, t_z = t\n\n e = [rho_x, rho_y, rho_z, t_x, t_y, t_z]\n\n packed_params.extend(e)\n\n packed_params = np.array(packed_params,dtype=object)\n return packed_params","def get_params(self):\n return self.arr","def _get_model(self):\n\n parameters = {keys._topology:self.topology,\n keys._size:self.size,\n keys._name:self.name,\n #keys._output_activation:self._outActiv_fun_key,\n #keys._hidden_activation:self._hiddenActiv_fun_key,\n keys._learning_rate:self.learningRate,\n keys._momentum:self.momentum}\n\n return parameters","def designMatrix(self,x,m):\n\n phi = []\n\n for i in x:\n matric = []\n for j in range(0, m + 1):\n matric.append(np.power(i,j))\n phi.append(matric)\n return np.asarray(phi)","def _get_proj_mat(self):\n if self._proj_mat is None:\n if self.symmetric:\n IP_mat = self.vec_space.compute_symmetric_inner_product_mat(\n self.basis_vec_handles)\n else:\n IP_mat = self.vec_space.compute_inner_product_mat(\n self.adjoint_basis_vec_handles, self.basis_vec_handles)\n self._proj_mat = np.linalg.inv(IP_mat)\n return self._proj_mat","def e(self):\n return np.matrix([self.y - self.arg[0,0]*self.x**3 - self.arg[1,0]*self.x**2 - self.arg[2,0]*self.x**1 - self.arg[3,0]])","def _xyz_matrix():\n fx = 583.0\n fy = 583.0\n cx = 321\n cy = 249\n a = -0.0028300396\n b = 3.1006268\n mat = np.array([[1/fx, 0, 0, -cx/fx],\n [0, -1/fy, 0, cy/fy],\n [0, 0, 0, -1],\n [0, 0, a, b]])\n return mat","def current_parameters(self):\n current = []\n for core_param in range(len(self.q)):\n for approx_param in range(self.q[core_param].param_no):\n current.append(self.q[core_param].vi_return_param(approx_param))\n return np.array(current)","def get_parameters(self):\n if self.add_bias:\n params = np.concatenate((self.bias, self.W), 0)\n else:\n params = self.W\n return params","def create_design_matrix(self):\n self.design_matrix = np.zeros([self.n, self.p])\n self.design_matrix[:,0] = 1.0 #First comlum is 1 (bias term)\n\n for i in range(self.n):\n for j in range(1,self.p):\n self.design_matrix[i,j] = self.phi(self.x[i],j)\n\n self.design_eigvals = np.linalg.eigvals(self.design_matrix.T@self.design_matrix)","def _get_proj_mat(self): \n if self._proj_mat is None:\n if self.symmetric:\n IP_mat = self.vec_space.compute_symmetric_inner_product_mat(\n self.basis_vecs)\n else:\n IP_mat = self.vec_space.compute_inner_product_mat(\n self.adjoint_basis_vecs, self.basis_vecs)\n self._proj_mat = np.linalg.inv(IP_mat)\n return self._proj_mat","def get_params(self):\n return deepcopy(np.hstack([to_numpy(v).flatten() for v in\n self.parameters()]))","def getInverseMatrix(self) -> CMatrix4:\n ...","def parameters(self):\n # encoded in θ\n return self.theta.columns","def parameters(self, t):\n if self.fixed_params:\n return (self.As[:, :, 0], self.Bs[:, :, 0], self.Cs[:, :, 0], self.Ds[:, :, 0],\n self.Qs[:, :, 0], self.Rs[:, :, 0])\n\n return (self.As[:, :, t + 1], self.Bs[:, :, t + 1], self.Cs[:, :, t + 1], self.Ds[:, :, t + 1],\n self.Qs[:, :, t + 1], self.Rs[:, :, t + 1])","def get_projection_matrix(self, aspect):\n return self.ptr.get_projection_matrix(aspect)","def def_paramt():\n Zeff = 1.0\n amu = 2.0\n mf = mp*amu\n return Zeff, amu,mf","def information_matrix(self):\n return self._cov.inv()","def parameters(self):\n return {\"W\": self.W,\n \"T\": self.T,\n \"P\": self.P}","def get_iperparams(self):\n\t\treturn (self.D, self.K)","def P(self):\n self.eigenmatrix()","def _get_params(self):\r\n return np.hstack((self.varianceU,self.varianceY, self.lengthscaleU,self.lengthscaleY))","def _get_params(self):\r\n return np.hstack((self.varianceU,self.varianceY, self.lengthscaleU,self.lengthscaleY))","def __call__(self): \n m = np.zeros((len(self.observation),))\n k = np.zeros((len(self.observation), len(self.prior)))\n \n sv = self.stateVector\n m = sv[0] * np.exp(-(self.independentVariable/sv[1])) + sv[2]\n \n k[:, 0] = np.exp(-(self.independentVariable/sv[1]))\n k[:, 1] = (sv[0] * self.independentVariable * \n np.exp(-(self.independentVariable/sv[1]))/(sv[1])**2)\n k[:, 2] = np.ones((len(self.observation),))\n \n self.modelCalculation, self.Jacobian = m, k\n \n return m, k","def test_active_matrix_from_extrinsic_euler_zxz():\n assert_array_almost_equal(\n pr.active_matrix_from_extrinsic_euler_zxz([0.5 * np.pi, 0, 0]),\n np.array([\n [0, -1, 0],\n [1, 0, 0],\n [0, 0, 1]\n ])\n )\n assert_array_almost_equal(\n pr.active_matrix_from_extrinsic_euler_zxz(\n [0.5 * np.pi, 0, 0.5 * np.pi]),\n np.array([\n [-1, 0, 0],\n [0, -1, 0],\n [0, 0, 1]\n ])\n )\n assert_array_almost_equal(\n pr.active_matrix_from_extrinsic_euler_zxz(\n [0.5 * np.pi, 0.5 * np.pi, 0]),\n np.array([\n [0, -1, 0],\n [0, 0, -1],\n [1, 0, 0]\n ])\n )\n assert_array_almost_equal(\n pr.active_matrix_from_extrinsic_euler_zxz(\n [0.5 * np.pi, 0.5 * np.pi, 0.5 * np.pi]),\n np.array([\n [0, 0, 1],\n [0, -1, 0],\n [1, 0, 0]\n ])\n )","def getCameraMatrix(self): # real signature unknown; restored from __doc__\n pass","def parameters(self):\n #print \"in instrument.parameter()\"\n return self._params","def get_affine_reg_params(self):\n affine_params = [\n self.affine_reg_pyramid_steps,\n self.affine_reg_used_pyramid_steps,\n ]\n return affine_params","def paramDetails(cls):\n return {\n 'dim': (10, 20, 2, 20),\n 'nIter': (1, 10, 2, 5),\n 'lamb': (.1, 1., .1, .05),\n 'alph': (30, 50, 5, 40)\n }","def get_matrix(self):\n return self._matrix[:3, :]","def getMatrix(self, frame):\n self.matrix[3, 0]=self.getValue(frame)\n return self.matrix","def getMatrix(self, frame):\n self.matrix[3, 1]=self.getValue(frame)\n return self.matrix","def get_em_parameters(self):\n raise DeviceException(DeviceException.FEATURE_NOT_IMPLEMENTED)","def affine_matrix(self) -> np.ndarray:\n return self._tf_matrix","def parameters(self):\n return {\"P\": self.P,\n \"T\": self.T}","def get_parameters(self):\n params = np.concatenate([p.contiguous().view(-1).data.numpy()\n for p in self.__network.parameters()])\n return params.copy()","def parameters(self):\n return self.pars","def get_variables(self) -> np.array:\n return np.array([self.m, self.c])","def design_matrix(nonlinear_p, data, prior):\n P, ecc, omega, M0 = nonlinear_p[:4] # we don't need the jitter here\n\n t = data._t_bmjd\n t0 = data._t_ref_bmjd\n zdot = cy_rv_from_elements(t, P, 1., ecc, omega, M0, t0, 1e-8, 128)\n\n M1 = np.vander(t - t0, N=prior.poly_trend, increasing=True)\n M = np.hstack((zdot[:, None], M1))\n\n return M","def test_active_matrix_from_extrinsic_euler_zyz():\n assert_array_almost_equal(\n pr.active_matrix_from_extrinsic_roll_pitch_yaw([0.5 * np.pi, 0, 0]),\n np.array([\n [1, 0, 0],\n [0, 0, -1],\n [0, 1, 0]\n ])\n )\n assert_array_almost_equal(\n pr.active_matrix_from_extrinsic_roll_pitch_yaw(\n [0.5 * np.pi, 0, 0.5 * np.pi]),\n np.array([\n [0, 0, 1],\n [1, 0, 0],\n [0, 1, 0]\n ])\n )\n assert_array_almost_equal(\n pr.active_matrix_from_extrinsic_roll_pitch_yaw(\n [0.5 * np.pi, 0.5 * np.pi, 0]),\n np.array([\n [0, 1, 0],\n [0, 0, -1],\n [-1, 0, 0]\n ])\n )\n assert_array_almost_equal(\n pr.active_matrix_from_extrinsic_roll_pitch_yaw(\n [0.5 * np.pi, 0.5 * np.pi, 0.5 * np.pi]),\n np.array([\n [0, 0, 1],\n [0, 1, 0],\n [-1, 0, 0]\n ])\n )","def getMatrix(self, frame):\n self.matrix[3, 2]=self.getValue(frame)\n return self.matrix","def getParameters(self):\n\n current_params = {'taux': self.taux, 'mu': self.mu, 'G': self.G, 'alpha_0': self.alpha_0,\n 'delta': self.delta, 'p': self.p, 'I0': self.I0, 'kparam': self.kparam}\n\n return (current_params)","def test_get_param_matrix_coords(self):\n f81 = F81()\n self.assertEqual(f81.get_param_matrix_coords(), {})\n self.assertTrue(\n len(f81.get_param_matrix_coords(include_ref_cell=True)[\"ref_cell\"]) == 12\n )\n hky85 = HKY85()\n coords = hky85.get_param_matrix_coords()\n self.assertEqual(set(coords), set([\"kappa\"]))\n coords = hky85.get_param_matrix_coords(include_ref_cell=True)\n self.assertEqual(set(coords), set([\"kappa\", \"ref_cell\"]))\n gn = GN()\n coords = gn.get_param_matrix_coords(include_ref_cell=True)\n self.assertTrue(len(coords) == 12)\n self.assertTrue(len(coords[\"ref_cell\"]) == 1)","def predict_mat(self):\n mat = self.covs_mat.dot(self.alpha)\n return mat.reshape(self.shape)","def _get_params(self):\r\n return np.hstack((self.variance,self.lengthscale,self.period))","def _get_params(self):\r\n return np.hstack((self.variance,self.lengthscale,self.period))","def _get_params(self):\r\n return np.hstack((self.variance,self.lengthscale,self.period))","def intrinsic_matrix_inv(self) -> np.ndarray:\n\n # determinant of top left of intrinsic matrix\n tldet = self.kx * self.ky\n\n return np.array([[1 / self.kx, -self.kxy / tldet, (self.py * self.kxy - self.ky * self.px) / tldet],\n [0, 1 / self.ky, -self.py / self.ky]])","def get_cov_matrix_parameters(self):\n cov = numpy.diag(numpy.zeros(self.get_num_parameters()))\n i = 0\n for p in self.parameters:\n cov[i,i] = p.get_covariance()\n i += 1\n return cov","def getTranslationMatrix(tx, ty, tz):\n return MatrixExtended([\n [1, 0, 0, tx],\n [0, 1, 0, ty],\n [0, 0, 1, tz],\n [0, 0, 0, 1]])","def parameters(self):\n\n m = self.__m\n s = linalg.cholesky(self.__prod).transpose()\n w = self.__weight\n\n # Compute the parameters of the posterior distribution.\n return linalg.solve(s[:m, :m], s[:m, m:]), \\\n np.dot(s[:m, :m].transpose(), s[:m, :m]), \\\n np.dot(s[m:, m:].transpose(), s[m:, m:]) / w, \\\n w","def get_params(self) -> torch.Tensor:\n params = []\n for pp in list(self.net.parameters()):\n params.append(pp.view(-1))\n return torch.cat(params)","def CreateDesignMatrix_X(z, x, y, n ):\n if len(x.shape) > 1:\n x = np.ravel(x)\n y = np.ravel(y)\n\n N = len(x)\n l = int((n+1)*(n+2)/2) \n X = np.ones((N,l))\n\n for i in range(1,n+1):\n q = int((i)*(i+1)/2)\n for k in range(i+1):\n X[:,q+k] = x**(i-k) * y**k\n \n X, z_, indicies = shuffle(X, z)\n X_train, X_test, z_train, z_test = train_test_split(X, z_, test_size=split_train_test, random_state=seed, shuffle=False)\n X_test, X_val, z_test, z_val = train_test_split(X_test, z_test, test_size=split_test_val, random_state=seed, shuffle=False)\n\n return X, X_train, X_test, X_val, z_train, z_test, z_val, indicies","def CreateMatrix(self) -> BaseMatrix:","def CreateMatrix(self) -> BaseMatrix:","def unpack_refinement_params(params):\n intrinsics = params[:10]\n\n # Unpack intrinsics\n alpha, beta, gamma, u_c, v_c, k1, k2, k3 ,p1, p2 = intrinsics\n K = np.array([[alpha, gamma, u_c],\n [ 0., beta, v_c],\n [ 0., 0., 1.]])\n k = np.array([k1, k2, k3, p1, p2])\n\n # Unpack extrinsics\n extrinsic_matrices = []\n for i in range(10, len(params), 6):\n E_rodrigues = params[i:i+6]\n rho_x, rho_y, rho_z, t_x, t_y, t_z = E_rodrigues\n R = cv2.Rodrigues(np.array([rho_x, rho_y, rho_z]))[0]\n t = np.array([t_x, t_y, t_z])\n\n E = np.zeros((3, 4))\n E[:3, :3] = R\n E[:, 3] = t\n\n extrinsic_matrices.append(E)\n\n return K, k, extrinsic_matrices","def get_remat(self) -> ndarray:\n return self.data.weight[:, None]*self.revar.mapping.mat","def modelview_matrix(self):\n camera = self.figure.scene.camera\n return camera.view_transform_matrix.to_array().astype(np.float32)","def get_parameter_dict(self):\n prm = ModelParameters()\n prm.define(\"a\", self.a)\n return prm","def getProjectionMatrix(sorted_eigvecs):\n matrix_w = np.vstack(sorted_eigvecs).transpose()\n return matrix_w","def get_unitary(self, params: Sequence[float] = []) -> UnitaryMatrix:\n self.check_parameters(params)\n\n H = dot_product(params, self.sigmav)\n eiH = sp.linalg.expm(H)\n return UnitaryMatrix(eiH, check_arguments=False)","def Omat(self):\n if self.standard:\n return np.matrix(((0, -1, 0), (0, 0, 1), (-1, 0, 0)))\n else:\n return np.matrix(((0, 0, 1), (0, 1, 0), (-1, 0, 0)))","def mat(self) -> np.ndarray:\n Tp = ToeplitzificationOperator(P=self.P, M=self.M, dtype=self.x.dtype)\n return Tp.matvec(self.x)","def get_vm_parameters(self):\n return (self.__mu, self.__kappa)","def getParam(self):\n return self.__alpha0, self.__alpha1, self.__beta, self.__eta","def projection_matrix(self):\n scene = self.figure.scene\n scene_size = tuple(scene.get_size())\n aspect_ratio = float(scene_size[0]) / float(scene_size[1])\n p = scene.camera.get_perspective_transform_matrix(\n aspect_ratio, -1, 1).to_array().astype(np.float32)\n return p","def parameters(self):\n parameters = np.concatenate( (np.ravel(self.noise_var),\\\n self.kern.parameters), axis=0)\n\n # check if the parameters have changed\n if not np.array_equal(parameters, self._previous_parameters):\n # remove the internal variables that rely on the parameters\n for attr in self.dependent_attributes:\n setattr(self, attr, None)\n # update the previous parameter array\n self._previous_parameters = parameters.copy()\n return parameters.copy()","def get_view_matrix(self):\n return self.ptr.get_view_matrix()","def getTransportMatrix(self):\n\t\treturn self.trMtrx","def model(self):\n return numpy.array([\n [self.x1, self.y1],\n [self.x2, self.y2],\n [self.x3, self.x3]\n ])","def _mn_par_ ( self , i ) :\n if not i in self : raise IndexError\n #\n val = ctypes.c_double ( 0 ) \n err = ctypes.c_double ( 0 ) \n #\n res = self.GetParameter ( i , val , err )\n #\n val = float ( val.value )\n err = float ( err.value )\n #\n return VE ( val , err*err )","def obtain_parameterized_exchanges(self):\n\n lca = self.lca\n\n exchanges = self.ParametersModel.run(self.parameters)\n\n indices_tech = np.array([], dtype=int)\n indices_bio = np.array([], dtype=int)\n\n get_input = lambda exc: (exc['input_db'], exc['input_code'])\n get_output = lambda exc: (exc['output_db'], exc['output_code'])\n\n exc_tech = np.array([exc for exc in exchanges if get_input(exc) in lca.activity_dict])\n if exc_tech.shape[0] != 0:\n mask_tech = lambda i,j : np.where( np.all([lca.tech_params['row']==i, lca.tech_params['col']==j], axis=0) )\n indices_tech = np.hstack([ mask_tech( lca.activity_dict[get_input(exc)],lca.activity_dict[get_output(exc)] ) \\\n for exc in exc_tech]) [0]\n\n exc_bio = np.array([exc for exc in exchanges if get_input(exc) in lca.biosphere_dict])\n if exc_bio.shape[0] != 0:\n mask_bio = lambda i,j : np.where( np.all([lca.bio_params['row']==i, lca.bio_params['col']==j], axis=0) )\n indices_bio = np.hstack([ mask_bio( lca.biosphere_dict[get_input(exc)],lca.activity_dict[get_output(exc)] ) \\\n for exc in exc_bio]) [0]\n parameters_dict = {}\n\n parameters_dict['tech_params_where'] = indices_tech\n parameters_dict['tech_params_amounts'] = np.array([ exc['amount'] for exc in exc_tech ])\n parameters_dict['tech_n_params'] = len(indices_tech)\n\n parameters_dict['bio_params_where'] = indices_bio\n parameters_dict['bio_params_amounts'] = np.array([ exc['amount'] for exc in exc_bio ])\n parameters_dict['bio_n_params'] = len(indices_bio)\n\n # TODO remove this check later on maybe\n assert indices_tech.shape[0] == parameters_dict['tech_n_params']\n assert indices_bio.shape[0] == parameters_dict['bio_n_params']\n\n self.parameters_dict = parameters_dict","def get_transform_matrix(theta, phi = None, invert_rot = False, invert_focal = False):\n\n if phi is None:\n phi = const.PHI_IDX * 10.0\n\n #extrinsic x intrinsic\n camera_matrix = np.zeros((4, 4), dtype=np.float32)\n\n intrinsic_matrix = np.eye(4, dtype=np.float32)\n extrinsic_matrix = np.eye(4, dtype=np.float32)\n\n sin_phi = np.sin(float(phi) / 180.0 * np.pi)\n cos_phi = np.cos(float(phi) / 180.0 * np.pi)\n sin_theta = np.sin(float(-theta) / 180.0 * np.pi)\n cos_theta = np.cos(float(-theta) / 180.0 * np.pi)\n\n #theta rotation\n rotation_azimuth = np.zeros((3, 3), dtype=np.float32)\n rotation_azimuth[0, 0] = cos_theta\n rotation_azimuth[2, 2] = cos_theta\n rotation_azimuth[0, 2] = -sin_theta\n rotation_azimuth[2, 0] = sin_theta\n rotation_azimuth[1, 1] = 1.0\n\n #phi rotation\n rotation_elevation = np.zeros((3, 3), dtype=np.float32)\n rotation_elevation[0, 0] = cos_phi\n rotation_elevation[0, 1] = sin_phi\n rotation_elevation[1, 0] = -sin_phi\n rotation_elevation[1, 1] = cos_phi\n rotation_elevation[2, 2] = 1.0\n\n #rotate phi, then theta\n rotation_matrix = np.matmul(rotation_azimuth, rotation_elevation)\n if invert_rot:\n rotation_matrix = np.linalg.inv(rotation_matrix)\n\n displacement = np.zeros((3, 1), dtype=np.float32)\n displacement[0, 0] = const.DIST_TO_CAM\n displacement = np.matmul(rotation_matrix, displacement)\n\n #assembling 4x4 from R + T\n extrinsic_matrix[0:3, 0:3] = rotation_matrix\n extrinsic_matrix[0:3, 3:4] = -displacement\n\n if invert_focal:\n intrinsic_matrix[2, 2] = float(const.focal_length)\n intrinsic_matrix[1, 1] = float(const.focal_length)\n else:\n intrinsic_matrix[2, 2] = 1.0 / float(const.focal_length)\n intrinsic_matrix[1, 1] = 1.0 / float(const.focal_length)\n\n camera_matrix = np.matmul(extrinsic_matrix, intrinsic_matrix)\n return camera_matrix","def matrix(self) -> sympy.Matrix:\n return self.matrix_factory(*self.params)","def get_parameter_values(self):\n obsPars = numpy.zeros(self.get_num_parameters())\n i = 0\n for p in self.parameters:\n obsPars[i] = p.read_value_in_fmu(self.fmu)\n i += 1\n return obsPars","def parameters(self):\n return {\n 'base':self.base.parameters(),\n 'material':[m.parameters() for m in self.material],\n 'fraction':self.fraction,\n }","def pose2mat(pose):\n extrinsic = torch.eye(4)\n extrinsic[:3, :] = pose[:, :4]\n inv_extrinsic = torch.inverse(extrinsic)\n extrinsic = torch.inverse(inv_extrinsic)\n h, w, focal_length = pose[:, 4]\n intrinsic = torch.Tensor([[focal_length, 0, w/2],\n [0, focal_length, h/2],\n [0, 0, 1]])\n\n return extrinsic, intrinsic","def _get_params(self):\r\n return np.hstack((self.variance,self.lengthscale))","def exteriorOrientationParameters(self):\n return self.__exteriorOrientationParameters","def eff_param_string():\n return '[0] * (1 - [1] * (TMath::Erf(x[0] + [2]) - [1] / [4] * (x[0] - [3] * (pow(x[0], 2) - [3] / [5] * pow(x[0], 3)))))'","def _get_estimate_matrices(self):\n params_mapping = {\n \"state_transition\": \"transition_matrices\",\n \"process_noise\": \"transition_covariance\",\n \"measurement_offsets\": \"observation_offsets\",\n \"transition_offsets\": \"transition_offsets\",\n \"measurement_noise\": \"observation_covariance\",\n \"measurement_function\": \"observation_matrices\",\n \"initial_state\": \"initial_state_mean\",\n \"initial_state_covariance\": \"initial_state_covariance\",\n }\n valid_ems = _validate_estimate_matrices(\n input_ems=self.estimate_matrices, all_ems=list(params_mapping.keys())\n )\n\n em_vars = [params_mapping[em_var] for em_var in valid_ems]\n return em_vars","def getTransposeMatrix(self) -> CMatrix4:\n ..."],"string":"[\n \"def get_intrinsic_mat(params):\\n return np.asarray(\\n [\\n [params[0], 0.0, params[1]],\\n [0.0, params[2], params[3]],\\n [0.0, 0.0, 1.0],\\n ]\\n )\",\n \"def get_extrinsic_matrix(pose):\\n batch_size, _ = pose.shape\\n rot = pose[:,:3]\\n trans = pose[:,3:]\\n\\n rot = transforms.euler_angles_to_matrix(rot,convention=\\\"XYZ\\\")\\n pose = torch.cat((rot,trans.view(batch_size, 3, 1)), -1)\\n\\n return pose\",\n \"def extrinsic(self):\\n return self._extrinsic\",\n \"def matrix_param(self):\\n return self.__matrix_param\",\n \"def getParameters(self):\\n params = []\\n for m in [self.ix, self.ih, self.fx, self.fh, self.ox, self.oh, self.ux, self.uh]:\\n # we do not get param of output module\\n l = list(m.parameters())\\n params.extend(l)\\n\\n one_dim = [p.view(p.numel()) for p in params]\\n params = F.torch.cat(one_dim)\\n return params\",\n \"def getParameters(self):\\n params = []\\n for m in [self.ix, self.ih, self.fx, self.fh, self.ox, self.oh, self.ux, self.uh]:\\n # we do not get param of output module\\n l = list(m.parameters())\\n params.extend(l)\\n\\n one_dim = [p.view(p.numel()) for p in params]\\n params = F.torch.cat(one_dim)\\n return params\",\n \"def get_params(self) -> np.array:\\n pass\",\n \"def getMatrix(self) -> CMatrix4:\\n ...\",\n \"def _get_params(self):\\r\\n x = np.hstack((self.X.flatten(), self.X_variance.flatten(), SparseGP._get_params(self)))\\r\\n return x\",\n \"def get_parameters(self):\\n return self.sess.run(self.A_symm)\",\n \"def params(self):\\n return {'out_dim': self.out_dim,\\n 'act_fn': self.act_fn,\\n 'use_bias': self.use_bias,\\n 'idx': self.idx}\",\n \"def get_params_array(self):\\n return np.array(self.W), np.array(self.b)\",\n \"def get_model_params(self):\\n\\n results = self._model.fit()\\n model_params = np.expand_dims(results.params.as_matrix(), 1)\\n return model_params\",\n \"def matrix(self):\\n return self._matrix(*self.parameters)\",\n \"def M(self):\\n return _hypre.HypreParMatrix_M(self)\",\n \"def get_design_matrix(x):\\n\\tF = np.ones((10, 1))\\n\\tF = np.hstack((F, x))\\n\\n\\treturn F\",\n \"def _get_params(self):\\r\\n return np.hstack((self.k1._get_params(), self.k2._get_params()))\",\n \"def _get_params(self):\\r\\n return np.hstack((self.k1._get_params(), self.k2._get_params()))\",\n \"def pack_params(K, k, extrinsic_matrices):\\n packed_params = []\\n\\n # Flatten intrinsics\\n alpha, beta, gamma, u_c, v_c = K[0,0], K[1,1], K[0,1], K[0,2], K[1,2]\\n k1, k2, k3 ,p1, p2 = k\\n\\n a = [alpha, beta, gamma, u_c, v_c,k1, k2, k3, p1, p2 ]\\n\\n packed_params.extend(a)\\n\\n # Flattened extrinsics\\n for E in extrinsic_matrices:\\n # Convert extrinsics to flattened Rodrigues representation\\n R = E[:3, :3]\\n t = E[:, 3]\\n\\n rodrigues = cv2.Rodrigues(R)[0]\\n\\n rho_x, rho_y, rho_z = rodrigues\\n t_x, t_y, t_z = t\\n\\n e = [rho_x, rho_y, rho_z, t_x, t_y, t_z]\\n\\n packed_params.extend(e)\\n\\n packed_params = np.array(packed_params,dtype=object)\\n return packed_params\",\n \"def get_params(self):\\n return self.arr\",\n \"def _get_model(self):\\n\\n parameters = {keys._topology:self.topology,\\n keys._size:self.size,\\n keys._name:self.name,\\n #keys._output_activation:self._outActiv_fun_key,\\n #keys._hidden_activation:self._hiddenActiv_fun_key,\\n keys._learning_rate:self.learningRate,\\n keys._momentum:self.momentum}\\n\\n return parameters\",\n \"def designMatrix(self,x,m):\\n\\n phi = []\\n\\n for i in x:\\n matric = []\\n for j in range(0, m + 1):\\n matric.append(np.power(i,j))\\n phi.append(matric)\\n return np.asarray(phi)\",\n \"def _get_proj_mat(self):\\n if self._proj_mat is None:\\n if self.symmetric:\\n IP_mat = self.vec_space.compute_symmetric_inner_product_mat(\\n self.basis_vec_handles)\\n else:\\n IP_mat = self.vec_space.compute_inner_product_mat(\\n self.adjoint_basis_vec_handles, self.basis_vec_handles)\\n self._proj_mat = np.linalg.inv(IP_mat)\\n return self._proj_mat\",\n \"def e(self):\\n return np.matrix([self.y - self.arg[0,0]*self.x**3 - self.arg[1,0]*self.x**2 - self.arg[2,0]*self.x**1 - self.arg[3,0]])\",\n \"def _xyz_matrix():\\n fx = 583.0\\n fy = 583.0\\n cx = 321\\n cy = 249\\n a = -0.0028300396\\n b = 3.1006268\\n mat = np.array([[1/fx, 0, 0, -cx/fx],\\n [0, -1/fy, 0, cy/fy],\\n [0, 0, 0, -1],\\n [0, 0, a, b]])\\n return mat\",\n \"def current_parameters(self):\\n current = []\\n for core_param in range(len(self.q)):\\n for approx_param in range(self.q[core_param].param_no):\\n current.append(self.q[core_param].vi_return_param(approx_param))\\n return np.array(current)\",\n \"def get_parameters(self):\\n if self.add_bias:\\n params = np.concatenate((self.bias, self.W), 0)\\n else:\\n params = self.W\\n return params\",\n \"def create_design_matrix(self):\\n self.design_matrix = np.zeros([self.n, self.p])\\n self.design_matrix[:,0] = 1.0 #First comlum is 1 (bias term)\\n\\n for i in range(self.n):\\n for j in range(1,self.p):\\n self.design_matrix[i,j] = self.phi(self.x[i],j)\\n\\n self.design_eigvals = np.linalg.eigvals(self.design_matrix.T@self.design_matrix)\",\n \"def _get_proj_mat(self): \\n if self._proj_mat is None:\\n if self.symmetric:\\n IP_mat = self.vec_space.compute_symmetric_inner_product_mat(\\n self.basis_vecs)\\n else:\\n IP_mat = self.vec_space.compute_inner_product_mat(\\n self.adjoint_basis_vecs, self.basis_vecs)\\n self._proj_mat = np.linalg.inv(IP_mat)\\n return self._proj_mat\",\n \"def get_params(self):\\n return deepcopy(np.hstack([to_numpy(v).flatten() for v in\\n self.parameters()]))\",\n \"def getInverseMatrix(self) -> CMatrix4:\\n ...\",\n \"def parameters(self):\\n # encoded in θ\\n return self.theta.columns\",\n \"def parameters(self, t):\\n if self.fixed_params:\\n return (self.As[:, :, 0], self.Bs[:, :, 0], self.Cs[:, :, 0], self.Ds[:, :, 0],\\n self.Qs[:, :, 0], self.Rs[:, :, 0])\\n\\n return (self.As[:, :, t + 1], self.Bs[:, :, t + 1], self.Cs[:, :, t + 1], self.Ds[:, :, t + 1],\\n self.Qs[:, :, t + 1], self.Rs[:, :, t + 1])\",\n \"def get_projection_matrix(self, aspect):\\n return self.ptr.get_projection_matrix(aspect)\",\n \"def def_paramt():\\n Zeff = 1.0\\n amu = 2.0\\n mf = mp*amu\\n return Zeff, amu,mf\",\n \"def information_matrix(self):\\n return self._cov.inv()\",\n \"def parameters(self):\\n return {\\\"W\\\": self.W,\\n \\\"T\\\": self.T,\\n \\\"P\\\": self.P}\",\n \"def get_iperparams(self):\\n\\t\\treturn (self.D, self.K)\",\n \"def P(self):\\n self.eigenmatrix()\",\n \"def _get_params(self):\\r\\n return np.hstack((self.varianceU,self.varianceY, self.lengthscaleU,self.lengthscaleY))\",\n \"def _get_params(self):\\r\\n return np.hstack((self.varianceU,self.varianceY, self.lengthscaleU,self.lengthscaleY))\",\n \"def __call__(self): \\n m = np.zeros((len(self.observation),))\\n k = np.zeros((len(self.observation), len(self.prior)))\\n \\n sv = self.stateVector\\n m = sv[0] * np.exp(-(self.independentVariable/sv[1])) + sv[2]\\n \\n k[:, 0] = np.exp(-(self.independentVariable/sv[1]))\\n k[:, 1] = (sv[0] * self.independentVariable * \\n np.exp(-(self.independentVariable/sv[1]))/(sv[1])**2)\\n k[:, 2] = np.ones((len(self.observation),))\\n \\n self.modelCalculation, self.Jacobian = m, k\\n \\n return m, k\",\n \"def test_active_matrix_from_extrinsic_euler_zxz():\\n assert_array_almost_equal(\\n pr.active_matrix_from_extrinsic_euler_zxz([0.5 * np.pi, 0, 0]),\\n np.array([\\n [0, -1, 0],\\n [1, 0, 0],\\n [0, 0, 1]\\n ])\\n )\\n assert_array_almost_equal(\\n pr.active_matrix_from_extrinsic_euler_zxz(\\n [0.5 * np.pi, 0, 0.5 * np.pi]),\\n np.array([\\n [-1, 0, 0],\\n [0, -1, 0],\\n [0, 0, 1]\\n ])\\n )\\n assert_array_almost_equal(\\n pr.active_matrix_from_extrinsic_euler_zxz(\\n [0.5 * np.pi, 0.5 * np.pi, 0]),\\n np.array([\\n [0, -1, 0],\\n [0, 0, -1],\\n [1, 0, 0]\\n ])\\n )\\n assert_array_almost_equal(\\n pr.active_matrix_from_extrinsic_euler_zxz(\\n [0.5 * np.pi, 0.5 * np.pi, 0.5 * np.pi]),\\n np.array([\\n [0, 0, 1],\\n [0, -1, 0],\\n [1, 0, 0]\\n ])\\n )\",\n \"def getCameraMatrix(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def parameters(self):\\n #print \\\"in instrument.parameter()\\\"\\n return self._params\",\n \"def get_affine_reg_params(self):\\n affine_params = [\\n self.affine_reg_pyramid_steps,\\n self.affine_reg_used_pyramid_steps,\\n ]\\n return affine_params\",\n \"def paramDetails(cls):\\n return {\\n 'dim': (10, 20, 2, 20),\\n 'nIter': (1, 10, 2, 5),\\n 'lamb': (.1, 1., .1, .05),\\n 'alph': (30, 50, 5, 40)\\n }\",\n \"def get_matrix(self):\\n return self._matrix[:3, :]\",\n \"def getMatrix(self, frame):\\n self.matrix[3, 0]=self.getValue(frame)\\n return self.matrix\",\n \"def getMatrix(self, frame):\\n self.matrix[3, 1]=self.getValue(frame)\\n return self.matrix\",\n \"def get_em_parameters(self):\\n raise DeviceException(DeviceException.FEATURE_NOT_IMPLEMENTED)\",\n \"def affine_matrix(self) -> np.ndarray:\\n return self._tf_matrix\",\n \"def parameters(self):\\n return {\\\"P\\\": self.P,\\n \\\"T\\\": self.T}\",\n \"def get_parameters(self):\\n params = np.concatenate([p.contiguous().view(-1).data.numpy()\\n for p in self.__network.parameters()])\\n return params.copy()\",\n \"def parameters(self):\\n return self.pars\",\n \"def get_variables(self) -> np.array:\\n return np.array([self.m, self.c])\",\n \"def design_matrix(nonlinear_p, data, prior):\\n P, ecc, omega, M0 = nonlinear_p[:4] # we don't need the jitter here\\n\\n t = data._t_bmjd\\n t0 = data._t_ref_bmjd\\n zdot = cy_rv_from_elements(t, P, 1., ecc, omega, M0, t0, 1e-8, 128)\\n\\n M1 = np.vander(t - t0, N=prior.poly_trend, increasing=True)\\n M = np.hstack((zdot[:, None], M1))\\n\\n return M\",\n \"def test_active_matrix_from_extrinsic_euler_zyz():\\n assert_array_almost_equal(\\n pr.active_matrix_from_extrinsic_roll_pitch_yaw([0.5 * np.pi, 0, 0]),\\n np.array([\\n [1, 0, 0],\\n [0, 0, -1],\\n [0, 1, 0]\\n ])\\n )\\n assert_array_almost_equal(\\n pr.active_matrix_from_extrinsic_roll_pitch_yaw(\\n [0.5 * np.pi, 0, 0.5 * np.pi]),\\n np.array([\\n [0, 0, 1],\\n [1, 0, 0],\\n [0, 1, 0]\\n ])\\n )\\n assert_array_almost_equal(\\n pr.active_matrix_from_extrinsic_roll_pitch_yaw(\\n [0.5 * np.pi, 0.5 * np.pi, 0]),\\n np.array([\\n [0, 1, 0],\\n [0, 0, -1],\\n [-1, 0, 0]\\n ])\\n )\\n assert_array_almost_equal(\\n pr.active_matrix_from_extrinsic_roll_pitch_yaw(\\n [0.5 * np.pi, 0.5 * np.pi, 0.5 * np.pi]),\\n np.array([\\n [0, 0, 1],\\n [0, 1, 0],\\n [-1, 0, 0]\\n ])\\n )\",\n \"def getMatrix(self, frame):\\n self.matrix[3, 2]=self.getValue(frame)\\n return self.matrix\",\n \"def getParameters(self):\\n\\n current_params = {'taux': self.taux, 'mu': self.mu, 'G': self.G, 'alpha_0': self.alpha_0,\\n 'delta': self.delta, 'p': self.p, 'I0': self.I0, 'kparam': self.kparam}\\n\\n return (current_params)\",\n \"def test_get_param_matrix_coords(self):\\n f81 = F81()\\n self.assertEqual(f81.get_param_matrix_coords(), {})\\n self.assertTrue(\\n len(f81.get_param_matrix_coords(include_ref_cell=True)[\\\"ref_cell\\\"]) == 12\\n )\\n hky85 = HKY85()\\n coords = hky85.get_param_matrix_coords()\\n self.assertEqual(set(coords), set([\\\"kappa\\\"]))\\n coords = hky85.get_param_matrix_coords(include_ref_cell=True)\\n self.assertEqual(set(coords), set([\\\"kappa\\\", \\\"ref_cell\\\"]))\\n gn = GN()\\n coords = gn.get_param_matrix_coords(include_ref_cell=True)\\n self.assertTrue(len(coords) == 12)\\n self.assertTrue(len(coords[\\\"ref_cell\\\"]) == 1)\",\n \"def predict_mat(self):\\n mat = self.covs_mat.dot(self.alpha)\\n return mat.reshape(self.shape)\",\n \"def _get_params(self):\\r\\n return np.hstack((self.variance,self.lengthscale,self.period))\",\n \"def _get_params(self):\\r\\n return np.hstack((self.variance,self.lengthscale,self.period))\",\n \"def _get_params(self):\\r\\n return np.hstack((self.variance,self.lengthscale,self.period))\",\n \"def intrinsic_matrix_inv(self) -> np.ndarray:\\n\\n # determinant of top left of intrinsic matrix\\n tldet = self.kx * self.ky\\n\\n return np.array([[1 / self.kx, -self.kxy / tldet, (self.py * self.kxy - self.ky * self.px) / tldet],\\n [0, 1 / self.ky, -self.py / self.ky]])\",\n \"def get_cov_matrix_parameters(self):\\n cov = numpy.diag(numpy.zeros(self.get_num_parameters()))\\n i = 0\\n for p in self.parameters:\\n cov[i,i] = p.get_covariance()\\n i += 1\\n return cov\",\n \"def getTranslationMatrix(tx, ty, tz):\\n return MatrixExtended([\\n [1, 0, 0, tx],\\n [0, 1, 0, ty],\\n [0, 0, 1, tz],\\n [0, 0, 0, 1]])\",\n \"def parameters(self):\\n\\n m = self.__m\\n s = linalg.cholesky(self.__prod).transpose()\\n w = self.__weight\\n\\n # Compute the parameters of the posterior distribution.\\n return linalg.solve(s[:m, :m], s[:m, m:]), \\\\\\n np.dot(s[:m, :m].transpose(), s[:m, :m]), \\\\\\n np.dot(s[m:, m:].transpose(), s[m:, m:]) / w, \\\\\\n w\",\n \"def get_params(self) -> torch.Tensor:\\n params = []\\n for pp in list(self.net.parameters()):\\n params.append(pp.view(-1))\\n return torch.cat(params)\",\n \"def CreateDesignMatrix_X(z, x, y, n ):\\n if len(x.shape) > 1:\\n x = np.ravel(x)\\n y = np.ravel(y)\\n\\n N = len(x)\\n l = int((n+1)*(n+2)/2) \\n X = np.ones((N,l))\\n\\n for i in range(1,n+1):\\n q = int((i)*(i+1)/2)\\n for k in range(i+1):\\n X[:,q+k] = x**(i-k) * y**k\\n \\n X, z_, indicies = shuffle(X, z)\\n X_train, X_test, z_train, z_test = train_test_split(X, z_, test_size=split_train_test, random_state=seed, shuffle=False)\\n X_test, X_val, z_test, z_val = train_test_split(X_test, z_test, test_size=split_test_val, random_state=seed, shuffle=False)\\n\\n return X, X_train, X_test, X_val, z_train, z_test, z_val, indicies\",\n \"def CreateMatrix(self) -> BaseMatrix:\",\n \"def CreateMatrix(self) -> BaseMatrix:\",\n \"def unpack_refinement_params(params):\\n intrinsics = params[:10]\\n\\n # Unpack intrinsics\\n alpha, beta, gamma, u_c, v_c, k1, k2, k3 ,p1, p2 = intrinsics\\n K = np.array([[alpha, gamma, u_c],\\n [ 0., beta, v_c],\\n [ 0., 0., 1.]])\\n k = np.array([k1, k2, k3, p1, p2])\\n\\n # Unpack extrinsics\\n extrinsic_matrices = []\\n for i in range(10, len(params), 6):\\n E_rodrigues = params[i:i+6]\\n rho_x, rho_y, rho_z, t_x, t_y, t_z = E_rodrigues\\n R = cv2.Rodrigues(np.array([rho_x, rho_y, rho_z]))[0]\\n t = np.array([t_x, t_y, t_z])\\n\\n E = np.zeros((3, 4))\\n E[:3, :3] = R\\n E[:, 3] = t\\n\\n extrinsic_matrices.append(E)\\n\\n return K, k, extrinsic_matrices\",\n \"def get_remat(self) -> ndarray:\\n return self.data.weight[:, None]*self.revar.mapping.mat\",\n \"def modelview_matrix(self):\\n camera = self.figure.scene.camera\\n return camera.view_transform_matrix.to_array().astype(np.float32)\",\n \"def get_parameter_dict(self):\\n prm = ModelParameters()\\n prm.define(\\\"a\\\", self.a)\\n return prm\",\n \"def getProjectionMatrix(sorted_eigvecs):\\n matrix_w = np.vstack(sorted_eigvecs).transpose()\\n return matrix_w\",\n \"def get_unitary(self, params: Sequence[float] = []) -> UnitaryMatrix:\\n self.check_parameters(params)\\n\\n H = dot_product(params, self.sigmav)\\n eiH = sp.linalg.expm(H)\\n return UnitaryMatrix(eiH, check_arguments=False)\",\n \"def Omat(self):\\n if self.standard:\\n return np.matrix(((0, -1, 0), (0, 0, 1), (-1, 0, 0)))\\n else:\\n return np.matrix(((0, 0, 1), (0, 1, 0), (-1, 0, 0)))\",\n \"def mat(self) -> np.ndarray:\\n Tp = ToeplitzificationOperator(P=self.P, M=self.M, dtype=self.x.dtype)\\n return Tp.matvec(self.x)\",\n \"def get_vm_parameters(self):\\n return (self.__mu, self.__kappa)\",\n \"def getParam(self):\\n return self.__alpha0, self.__alpha1, self.__beta, self.__eta\",\n \"def projection_matrix(self):\\n scene = self.figure.scene\\n scene_size = tuple(scene.get_size())\\n aspect_ratio = float(scene_size[0]) / float(scene_size[1])\\n p = scene.camera.get_perspective_transform_matrix(\\n aspect_ratio, -1, 1).to_array().astype(np.float32)\\n return p\",\n \"def parameters(self):\\n parameters = np.concatenate( (np.ravel(self.noise_var),\\\\\\n self.kern.parameters), axis=0)\\n\\n # check if the parameters have changed\\n if not np.array_equal(parameters, self._previous_parameters):\\n # remove the internal variables that rely on the parameters\\n for attr in self.dependent_attributes:\\n setattr(self, attr, None)\\n # update the previous parameter array\\n self._previous_parameters = parameters.copy()\\n return parameters.copy()\",\n \"def get_view_matrix(self):\\n return self.ptr.get_view_matrix()\",\n \"def getTransportMatrix(self):\\n\\t\\treturn self.trMtrx\",\n \"def model(self):\\n return numpy.array([\\n [self.x1, self.y1],\\n [self.x2, self.y2],\\n [self.x3, self.x3]\\n ])\",\n \"def _mn_par_ ( self , i ) :\\n if not i in self : raise IndexError\\n #\\n val = ctypes.c_double ( 0 ) \\n err = ctypes.c_double ( 0 ) \\n #\\n res = self.GetParameter ( i , val , err )\\n #\\n val = float ( val.value )\\n err = float ( err.value )\\n #\\n return VE ( val , err*err )\",\n \"def obtain_parameterized_exchanges(self):\\n\\n lca = self.lca\\n\\n exchanges = self.ParametersModel.run(self.parameters)\\n\\n indices_tech = np.array([], dtype=int)\\n indices_bio = np.array([], dtype=int)\\n\\n get_input = lambda exc: (exc['input_db'], exc['input_code'])\\n get_output = lambda exc: (exc['output_db'], exc['output_code'])\\n\\n exc_tech = np.array([exc for exc in exchanges if get_input(exc) in lca.activity_dict])\\n if exc_tech.shape[0] != 0:\\n mask_tech = lambda i,j : np.where( np.all([lca.tech_params['row']==i, lca.tech_params['col']==j], axis=0) )\\n indices_tech = np.hstack([ mask_tech( lca.activity_dict[get_input(exc)],lca.activity_dict[get_output(exc)] ) \\\\\\n for exc in exc_tech]) [0]\\n\\n exc_bio = np.array([exc for exc in exchanges if get_input(exc) in lca.biosphere_dict])\\n if exc_bio.shape[0] != 0:\\n mask_bio = lambda i,j : np.where( np.all([lca.bio_params['row']==i, lca.bio_params['col']==j], axis=0) )\\n indices_bio = np.hstack([ mask_bio( lca.biosphere_dict[get_input(exc)],lca.activity_dict[get_output(exc)] ) \\\\\\n for exc in exc_bio]) [0]\\n parameters_dict = {}\\n\\n parameters_dict['tech_params_where'] = indices_tech\\n parameters_dict['tech_params_amounts'] = np.array([ exc['amount'] for exc in exc_tech ])\\n parameters_dict['tech_n_params'] = len(indices_tech)\\n\\n parameters_dict['bio_params_where'] = indices_bio\\n parameters_dict['bio_params_amounts'] = np.array([ exc['amount'] for exc in exc_bio ])\\n parameters_dict['bio_n_params'] = len(indices_bio)\\n\\n # TODO remove this check later on maybe\\n assert indices_tech.shape[0] == parameters_dict['tech_n_params']\\n assert indices_bio.shape[0] == parameters_dict['bio_n_params']\\n\\n self.parameters_dict = parameters_dict\",\n \"def get_transform_matrix(theta, phi = None, invert_rot = False, invert_focal = False):\\n\\n if phi is None:\\n phi = const.PHI_IDX * 10.0\\n\\n #extrinsic x intrinsic\\n camera_matrix = np.zeros((4, 4), dtype=np.float32)\\n\\n intrinsic_matrix = np.eye(4, dtype=np.float32)\\n extrinsic_matrix = np.eye(4, dtype=np.float32)\\n\\n sin_phi = np.sin(float(phi) / 180.0 * np.pi)\\n cos_phi = np.cos(float(phi) / 180.0 * np.pi)\\n sin_theta = np.sin(float(-theta) / 180.0 * np.pi)\\n cos_theta = np.cos(float(-theta) / 180.0 * np.pi)\\n\\n #theta rotation\\n rotation_azimuth = np.zeros((3, 3), dtype=np.float32)\\n rotation_azimuth[0, 0] = cos_theta\\n rotation_azimuth[2, 2] = cos_theta\\n rotation_azimuth[0, 2] = -sin_theta\\n rotation_azimuth[2, 0] = sin_theta\\n rotation_azimuth[1, 1] = 1.0\\n\\n #phi rotation\\n rotation_elevation = np.zeros((3, 3), dtype=np.float32)\\n rotation_elevation[0, 0] = cos_phi\\n rotation_elevation[0, 1] = sin_phi\\n rotation_elevation[1, 0] = -sin_phi\\n rotation_elevation[1, 1] = cos_phi\\n rotation_elevation[2, 2] = 1.0\\n\\n #rotate phi, then theta\\n rotation_matrix = np.matmul(rotation_azimuth, rotation_elevation)\\n if invert_rot:\\n rotation_matrix = np.linalg.inv(rotation_matrix)\\n\\n displacement = np.zeros((3, 1), dtype=np.float32)\\n displacement[0, 0] = const.DIST_TO_CAM\\n displacement = np.matmul(rotation_matrix, displacement)\\n\\n #assembling 4x4 from R + T\\n extrinsic_matrix[0:3, 0:3] = rotation_matrix\\n extrinsic_matrix[0:3, 3:4] = -displacement\\n\\n if invert_focal:\\n intrinsic_matrix[2, 2] = float(const.focal_length)\\n intrinsic_matrix[1, 1] = float(const.focal_length)\\n else:\\n intrinsic_matrix[2, 2] = 1.0 / float(const.focal_length)\\n intrinsic_matrix[1, 1] = 1.0 / float(const.focal_length)\\n\\n camera_matrix = np.matmul(extrinsic_matrix, intrinsic_matrix)\\n return camera_matrix\",\n \"def matrix(self) -> sympy.Matrix:\\n return self.matrix_factory(*self.params)\",\n \"def get_parameter_values(self):\\n obsPars = numpy.zeros(self.get_num_parameters())\\n i = 0\\n for p in self.parameters:\\n obsPars[i] = p.read_value_in_fmu(self.fmu)\\n i += 1\\n return obsPars\",\n \"def parameters(self):\\n return {\\n 'base':self.base.parameters(),\\n 'material':[m.parameters() for m in self.material],\\n 'fraction':self.fraction,\\n }\",\n \"def pose2mat(pose):\\n extrinsic = torch.eye(4)\\n extrinsic[:3, :] = pose[:, :4]\\n inv_extrinsic = torch.inverse(extrinsic)\\n extrinsic = torch.inverse(inv_extrinsic)\\n h, w, focal_length = pose[:, 4]\\n intrinsic = torch.Tensor([[focal_length, 0, w/2],\\n [0, focal_length, h/2],\\n [0, 0, 1]])\\n\\n return extrinsic, intrinsic\",\n \"def _get_params(self):\\r\\n return np.hstack((self.variance,self.lengthscale))\",\n \"def exteriorOrientationParameters(self):\\n return self.__exteriorOrientationParameters\",\n \"def eff_param_string():\\n return '[0] * (1 - [1] * (TMath::Erf(x[0] + [2]) - [1] / [4] * (x[0] - [3] * (pow(x[0], 2) - [3] / [5] * pow(x[0], 3)))))'\",\n \"def _get_estimate_matrices(self):\\n params_mapping = {\\n \\\"state_transition\\\": \\\"transition_matrices\\\",\\n \\\"process_noise\\\": \\\"transition_covariance\\\",\\n \\\"measurement_offsets\\\": \\\"observation_offsets\\\",\\n \\\"transition_offsets\\\": \\\"transition_offsets\\\",\\n \\\"measurement_noise\\\": \\\"observation_covariance\\\",\\n \\\"measurement_function\\\": \\\"observation_matrices\\\",\\n \\\"initial_state\\\": \\\"initial_state_mean\\\",\\n \\\"initial_state_covariance\\\": \\\"initial_state_covariance\\\",\\n }\\n valid_ems = _validate_estimate_matrices(\\n input_ems=self.estimate_matrices, all_ems=list(params_mapping.keys())\\n )\\n\\n em_vars = [params_mapping[em_var] for em_var in valid_ems]\\n return em_vars\",\n \"def getTransposeMatrix(self) -> CMatrix4:\\n ...\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7331173","0.63358027","0.63124555","0.6310796","0.61443675","0.61443675","0.61398846","0.6122645","0.6090896","0.59263265","0.58786243","0.5862724","0.5847503","0.58337194","0.57778543","0.5750955","0.57484686","0.57484686","0.5668891","0.5660093","0.56556934","0.5648544","0.5635101","0.5631414","0.56252795","0.56166553","0.56088704","0.5601754","0.5601537","0.5598446","0.55844545","0.5576991","0.5570305","0.55607903","0.5557442","0.55561656","0.55435544","0.5534627","0.5534272","0.552924","0.552924","0.5527447","0.5521204","0.5519148","0.5518834","0.5517484","0.5509614","0.55082035","0.5500788","0.54888505","0.54841316","0.54816264","0.5481105","0.5480313","0.54674155","0.54606974","0.54536694","0.5447419","0.54417795","0.54380196","0.5417599","0.5416744","0.54127085","0.54127085","0.54127085","0.5406963","0.5401217","0.54004127","0.5391224","0.53899634","0.53885734","0.5388177","0.5388177","0.5387547","0.53874177","0.5387057","0.5386207","0.5386146","0.53778535","0.5377387","0.5372034","0.5371653","0.53660333","0.53660214","0.5359419","0.5359244","0.5342121","0.534021","0.5340096","0.5336724","0.5330662","0.53274035","0.5326683","0.5313333","0.53093886","0.530823","0.5307088","0.53051525","0.5304977","0.52992827"],"string":"[\n \"0.7331173\",\n \"0.63358027\",\n \"0.63124555\",\n \"0.6310796\",\n \"0.61443675\",\n \"0.61443675\",\n \"0.61398846\",\n \"0.6122645\",\n \"0.6090896\",\n \"0.59263265\",\n \"0.58786243\",\n \"0.5862724\",\n \"0.5847503\",\n \"0.58337194\",\n \"0.57778543\",\n \"0.5750955\",\n \"0.57484686\",\n \"0.57484686\",\n \"0.5668891\",\n \"0.5660093\",\n \"0.56556934\",\n \"0.5648544\",\n \"0.5635101\",\n \"0.5631414\",\n \"0.56252795\",\n \"0.56166553\",\n \"0.56088704\",\n \"0.5601754\",\n \"0.5601537\",\n \"0.5598446\",\n \"0.55844545\",\n \"0.5576991\",\n \"0.5570305\",\n \"0.55607903\",\n \"0.5557442\",\n \"0.55561656\",\n \"0.55435544\",\n \"0.5534627\",\n \"0.5534272\",\n \"0.552924\",\n \"0.552924\",\n \"0.5527447\",\n \"0.5521204\",\n \"0.5519148\",\n \"0.5518834\",\n \"0.5517484\",\n \"0.5509614\",\n \"0.55082035\",\n \"0.5500788\",\n \"0.54888505\",\n \"0.54841316\",\n \"0.54816264\",\n \"0.5481105\",\n \"0.5480313\",\n \"0.54674155\",\n \"0.54606974\",\n \"0.54536694\",\n \"0.5447419\",\n \"0.54417795\",\n \"0.54380196\",\n \"0.5417599\",\n \"0.5416744\",\n \"0.54127085\",\n \"0.54127085\",\n \"0.54127085\",\n \"0.5406963\",\n \"0.5401217\",\n \"0.54004127\",\n \"0.5391224\",\n \"0.53899634\",\n \"0.53885734\",\n \"0.5388177\",\n \"0.5388177\",\n \"0.5387547\",\n \"0.53874177\",\n \"0.5387057\",\n \"0.5386207\",\n \"0.5386146\",\n \"0.53778535\",\n \"0.5377387\",\n \"0.5372034\",\n \"0.5371653\",\n \"0.53660333\",\n \"0.53660214\",\n \"0.5359419\",\n \"0.5359244\",\n \"0.5342121\",\n \"0.534021\",\n \"0.5340096\",\n \"0.5336724\",\n \"0.5330662\",\n \"0.53274035\",\n \"0.5326683\",\n \"0.5313333\",\n \"0.53093886\",\n \"0.530823\",\n \"0.5307088\",\n \"0.53051525\",\n \"0.5304977\",\n \"0.52992827\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6725677"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":396,"cells":{"query":{"kind":"string","value":"Gets the translation vector and rotation matrix of the camera w.r.t the world frame and removes camera frame ambiguity"},"document":{"kind":"string","value":"def getDisambiguousPose(K, C, R, left_features, right_features):\n check = 0\n for i in range(0, len(R)):\n count = 0\n extrinsic_params = getExtrinsicParameter(K, R[i], C[i])\n for j in range(0, len(left_features)):\n X = getTriangulationPoint(K, extrinsic_params, left_features[j], right_features[j])\n r3 = R[i][2, :].reshape((1, 3))\n cheiralityCondition = np.dot(r3, X[:3] - C[i])\n if cheiralityCondition > 0 and X[2] >= 0:\n count += 1\n if count > check:\n check = count\n Translation = C[i]\n Rotation = R[i]\n if Translation[2] < 0:\n Translation = -Translation\n return Translation, Rotation"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_camera_transform(self):\r\n if not self.pose:\r\n rospy.loginfo(\"no pose!\")\r\n return None\r\n if self.pose.header.frame_id != self.role_name:\r\n rospy.logwarn(\"Unsupported frame received. Supported {}, received {}\".format(\r\n self.role_name, self.pose.header.frame_id))\r\n return None\r\n sensor_location = carla.Location(x=self.pose.pose.position.x,\r\n y=-self.pose.pose.position.y,\r\n z=self.pose.pose.position.z)\r\n quaternion = (\r\n self.pose.pose.orientation.x,\r\n self.pose.pose.orientation.y,\r\n self.pose.pose.orientation.z,\r\n self.pose.pose.orientation.w\r\n )\r\n roll, pitch, yaw = euler_from_quaternion(quaternion)\r\n # rotate to CARLA\r\n sensor_rotation = carla.Rotation(pitch=math.degrees(roll)-90,\r\n roll=math.degrees(pitch),\r\n yaw=-math.degrees(yaw)-90)\r\n return carla.Transform(sensor_location, sensor_rotation)","def camera_matrix(self) -> TransformationMatrixType:\n return numpy.matmul(\n self.rotation_matrix(*self.rotation),\n displacement_matrix(*-numpy.array(self.location)),\n )","def getCameraMatrix(self): # real signature unknown; restored from __doc__\n pass","def get_transform_matrix(theta, phi = None, invert_rot = False, invert_focal = False):\n\n if phi is None:\n phi = const.PHI_IDX * 10.0\n\n #extrinsic x intrinsic\n camera_matrix = np.zeros((4, 4), dtype=np.float32)\n\n intrinsic_matrix = np.eye(4, dtype=np.float32)\n extrinsic_matrix = np.eye(4, dtype=np.float32)\n\n sin_phi = np.sin(float(phi) / 180.0 * np.pi)\n cos_phi = np.cos(float(phi) / 180.0 * np.pi)\n sin_theta = np.sin(float(-theta) / 180.0 * np.pi)\n cos_theta = np.cos(float(-theta) / 180.0 * np.pi)\n\n #theta rotation\n rotation_azimuth = np.zeros((3, 3), dtype=np.float32)\n rotation_azimuth[0, 0] = cos_theta\n rotation_azimuth[2, 2] = cos_theta\n rotation_azimuth[0, 2] = -sin_theta\n rotation_azimuth[2, 0] = sin_theta\n rotation_azimuth[1, 1] = 1.0\n\n #phi rotation\n rotation_elevation = np.zeros((3, 3), dtype=np.float32)\n rotation_elevation[0, 0] = cos_phi\n rotation_elevation[0, 1] = sin_phi\n rotation_elevation[1, 0] = -sin_phi\n rotation_elevation[1, 1] = cos_phi\n rotation_elevation[2, 2] = 1.0\n\n #rotate phi, then theta\n rotation_matrix = np.matmul(rotation_azimuth, rotation_elevation)\n if invert_rot:\n rotation_matrix = np.linalg.inv(rotation_matrix)\n\n displacement = np.zeros((3, 1), dtype=np.float32)\n displacement[0, 0] = const.DIST_TO_CAM\n displacement = np.matmul(rotation_matrix, displacement)\n\n #assembling 4x4 from R + T\n extrinsic_matrix[0:3, 0:3] = rotation_matrix\n extrinsic_matrix[0:3, 3:4] = -displacement\n\n if invert_focal:\n intrinsic_matrix[2, 2] = float(const.focal_length)\n intrinsic_matrix[1, 1] = float(const.focal_length)\n else:\n intrinsic_matrix[2, 2] = 1.0 / float(const.focal_length)\n intrinsic_matrix[1, 1] = 1.0 / float(const.focal_length)\n\n camera_matrix = np.matmul(extrinsic_matrix, intrinsic_matrix)\n return camera_matrix","def camera_transformation_from_pose(azimutal, elevation):\n azimutal, elevation = azimutal * 2. * np.pi / 360., elevation * 2. * np.pi / 360.\n azimutal *= -1.\n elevation *= -1.\n r_y = np.array([[np.cos(elevation), 0, np.sin(elevation)],\n [0, 1, 0],\n [-np.sin(elevation), 0, np.cos(elevation)]])\n r_z = np.array([[np.cos(azimutal), -np.sin(azimutal), 0],\n [np.sin(azimutal), np.cos(azimutal), 0],\n [0, 0, 1]])\n r = r_z.dot(r_y)\n # world_to_camera matrix, camera_to_world matrix\n return r, np.linalg.inv(r)","def telescope_to_camera(telescope_coord, camera_frame):\n x_pos = telescope_coord.cartesian.x\n y_pos = telescope_coord.cartesian.y\n rot = telescope_coord.rotation * -1 # reverse the rotation applied to get to this system\n\n if rot ==0: #if no rotation applied save a few cycles\n x=x_pos\n y=y_pos\n else: # or else rotate all positions around the camera centre\n x = x_pos*cos(rot) - y_pos*sin(rot)\n y = y_pos*sin(rot) + y_pos*cos(rot)\n\n f = telescope_coord.focal_length\n x = x*(f/u.m) # Remove distance units here as we are using small angle approx\n y = y*(f/u.m)\n\n representation = CartesianRepresentation(x.value*u.m ,y.value*u.m,0*u.m)\n\n return camera_frame.realize_frame(representation)","def get_frame(cap):\n\n #camera matrix for camera calibration\n mtx = np.array(np.mat(\"588.4525598886621, 0, 301.8008794717551; 0, 588.9763096391521, 242.617026416902; 0, 0, 1\"))\n\n #distrotion coefficients for camera calibration\n dist = np.array(np.mat(\"-0.4351555722591889, 0.2082765081608728, -0.006072767012672472, 0.008139871640987759, 0\"))\n\n #get image frame from the camera\n ret, frame = cap.read()\n\n return frame\n\n h, w = frame.shape[:2]\n\n #get the new optimal camera matrix and the roi which can be used to crop the result\n newcameramtx, roi=cv2.getOptimalNewCameraMatrix(mtx,dist,(w,h),0,(w,h))\n\n #get the undistroted image\n dst = cv2.undistort(frame, mtx, dist, None, newcameramtx)\n\n x,y,w,h = roi\n\n #get the cropped image\n dst = dst[y:y+h, x:x+w]\n h, w = dst.shape[:2]\n\n #furthur crop the image to reduce the size of arena\n dst = dst[int(h/7):int(h*6/7), int(w/7):int(w*6/7)]\n\n #resize the arena to ARENA_SIZE\n dst = cv2.resize(dst, ARENA_SIZE, interpolation= cv2.INTER_CUBIC)\n\n return dst","def camera_to_world(self, X):\n raise NotImplementedError","def world_to_camera(self, X):\n raise NotImplementedError","def ExtractCameraPose(E):\n u, s, v = np.linalg.svd(E, full_matrices=True)\n w = np.array([[0, -1, 0],\n [1, 0, 0],\n [0, 0, 1]]).reshape(3, 3)\n c1 = u[:, 2].reshape(3, 1)\n r1 = np.dot(np.dot(u, w), v).reshape(3, 3)\n c2 = -u[:, 2].reshape(3, 1)\n r2 = np.dot(np.dot(u, w), v).reshape(3, 3)\n c3 = u[:, 2].reshape(3, 1)\n r3 = np.dot(np.dot(u, w.T), v).reshape(3, 3)\n c4 = -u[:, 2].reshape(3, 1)\n r4 = np.dot(np.dot(u, w.T), v).reshape(3, 3)\n if np.linalg.det(r1) < 0:\n c1 = -c1\n r1 = -r1\n if np.linalg.det(r2) < 0:\n c2 = -c2\n r2 = -r2\n if np.linalg.det(r3) < 0:\n c3 = -c3\n r3 = -r3\n if np.linalg.det(r4) < 0:\n c4 = -c4\n r4 = -r4\n cam_center = np.array([c1, c2, c3, c4])\n cam_rotation = np.array([r1, r2, r3, r4])\n return cam_center, cam_rotation","def map_to_matrix(x, y):\n x_pos = round(x * ((MATRIX_SIZE_X - 1)/(FRAME_W - 1)))\n y_pos = round(y * ((MATRIX_SIZE_Y - 1)/(FRAME_H - 1)))\n\n x_pos = (MATRIX_SIZE_X - 1) - x_pos #invert x direction (left and right) to account for camera perspective\n\n return x_pos, y_pos","def getMatrix(self, frame):\n radian=np.radians(self.getValue(frame))\n c=np.cos(radian)\n s=np.sin(radian)\n self.matrix[2, 2]=c\n self.matrix[2, 0]=s\n self.matrix[0, 2]=-s\n self.matrix[0, 0]=c\n return self.matrix","def cameraToWorld(self, p):\n result = self.camPos\n result += p[2] * self.camZ # result is now in the middle of the view-plane\n result += p[0] * self.camX # result is now in the middle-left of the view-plane\n result += p[1] * self.camY # result is now the world-space equivalent of p\n return result","def modelview_matrix(self):\n camera = self.figure.scene.camera\n return camera.view_transform_matrix.to_array().astype(np.float32)","def camera_to_telescope(camera_coord, telescope_frame):\n x_pos = camera_coord.cartesian.x\n y_pos = camera_coord.cartesian.y\n\n rot = telescope_frame.rotation\n if rot ==0:\n x=x_pos\n y=y_pos\n else:\n x = x_pos*cos(rot) - y_pos*sin(rot)\n y = y_pos*sin(rot) + y_pos*cos(rot)\n\n f = telescope_frame.focal_length\n\n x = (x/f) * u.deg\n y = (y/f) * u.deg\n representation = CartesianRepresentation(x,y,0*u.deg)\n\n return telescope_frame.realize_frame(representation)","def camera_to_object_transform(self):\n # form the full object to camera transform\n T_stp_camera = self.stp_to_camera_transform()\n T_obj_stp = self.object_to_stp_transform()\n T_obj_camera = T_stp_camera.dot(T_obj_stp)\n return T_obj_camera","def create_cam2world_matrix(forward_vector,\n origin,\n device=None):\n \"\"\"\"\"\"\n\n forward_vector = normalize_vecs(forward_vector)\n up_vector = torch.tensor([0, 1, 0], dtype=torch.float, device=device) \\\n .expand_as(forward_vector)\n\n left_vector = normalize_vecs(\n torch.cross(up_vector,\n forward_vector,\n dim=-1))\n\n up_vector = normalize_vecs(\n torch.cross(forward_vector,\n left_vector,\n dim=-1))\n\n rotation_matrix = torch.eye(4, device=device) \\\n .unsqueeze(0) \\\n .repeat(forward_vector.shape[0], 1, 1)\n rotation_matrix[:, :3, :3] = torch.stack(\n (-left_vector, up_vector, -forward_vector), axis=-1)\n\n translation_matrix = torch.eye(4, device=device) \\\n .unsqueeze(0) \\\n .repeat(forward_vector.shape[0], 1, 1)\n translation_matrix[:, :3, 3] = origin\n\n cam2world = translation_matrix @ rotation_matrix\n\n return cam2world","def transform_camera_pose_to_world_pose(self):\n for pose in self.close_positions_camera:\n self.close_positions_world.append(self.get_world_pose_for_camera_pose(pose))\n\n for pose in self.medium_positions_camera:\n self.medium_positions_world.append(self.get_world_pose_for_camera_pose(pose))\n\n for pose in self.far_positions_camera:\n self.far_positions_world.append(self.get_world_pose_for_camera_pose(pose))","def computeMVP(self):\n projMat = self.converterYUR\n modelViewMat = self.transforMat.invertCompose(\n Globals.render.getTransform(self.cameraNode)).getMat()\n return UnalignedLMatrix4f(modelViewMat * projMat)","def get_transformation_matrix(self, fromFrame, toFrame):\n fromIndex = self.frameNames.index(fromFrame)\n toIndex = self.frameNames.index(toFrame)\n #return get_transformation_matrix(self.frameStack, fromIndex, toIndex)\n return self._get_transformation_matrix_with_indices(fromIndex, toIndex)","def getMatrix(self, frame):\n radian=np.radians(self.getValue(frame))\n c=np.cos(radian)\n s=np.sin(radian)\n self.matrix[1, 1]=c\n self.matrix[1, 2]=s\n self.matrix[2, 1]=-s\n self.matrix[2, 2]=c\n return self.matrix","def transformation_matrix(self) -> TransformationMatrixType:\n # camera translation\n if self._transformation_matrix is None:\n self._transformation_matrix = numpy.matmul(\n self.projection_matrix,\n self.camera_matrix,\n )\n\n return self._transformation_matrix","def proj_to_velo(calib_data):\n rect = calib_data[\"R0_rect\"].reshape(3, 3)\n #to transform a point from Lidar framce to camera frame\n #reshape the flat line with 12 elements to 3X4 matrix\n velo_to_cam = calib_data[\"Tr_velo_to_cam\"].reshape(3, 4)\n#print('velo2cam', velo_to_cam)\n inv_rect = np.linalg.inv(rect)\n #select all rows and only first three columns\n#print('velo_to_cam[:, :3]', velo_to_cam[:, :3])\n #select all rows and only first three columns\n inv_velo_to_cam = np.linalg.pinv(velo_to_cam[:, :3])\n return np.dot(inv_velo_to_cam, inv_rect)","def getMatrix(self, frame):\n radian=np.radians(self.getValue(frame))\n c=np.cos(radian)\n s=np.sin(radian)\n self.matrix[0, 0]=c\n self.matrix[0, 1]=s\n self.matrix[1, 0]=-s\n self.matrix[1, 1]=c\n return self.matrix","def read_camera(self):\n _, frame = self.camera.read()\n return self.mirror(frame)","def stp_to_camera_transform(self):\n # setup variables\n camera_xyz_w = self.cam_pos\n camera_rot_w = self.cam_rot\n camera_int_pt_w = self.cam_interest_pt\n camera_xyz_obj_p = camera_xyz_w - camera_int_pt_w\n \n # get the distance from the camera to the world\n camera_dist_xy = np.linalg.norm(camera_xyz_w[:2])\n z = [0,0,np.linalg.norm(camera_xyz_w[:3])]\n\n # form the rotations about the x and z axis for the object on the tabletop\n theta = camera_rot_w[0] * np.pi / 180.0\n phi = -camera_rot_w[2] * np.pi / 180.0 + np.pi / 2.0\n camera_rot_obj_p_z = np.array([[np.cos(phi), -np.sin(phi), 0],\n [np.sin(phi), np.cos(phi), 0],\n [0, 0, 1]])\n\n camera_rot_obj_p_x = np.array([[1, 0, 0],\n [0, np.cos(theta), -np.sin(theta)],\n [0, np.sin(theta), np.cos(theta)]])\n \n # form the full rotation matrix, swapping axes to match maya\n camera_md = np.array([[0, 1, 0],\n [1, 0, 0],\n [0, 0, -1]])\n camera_rot_obj_p = camera_md.dot(camera_rot_obj_p_z.dot(camera_rot_obj_p_x))\n camera_rot_obj_p = camera_rot_obj_p.T\n \n # form the full object to camera transform\n R_stp_camera = camera_rot_obj_p\n t_stp_camera = np.array(z)\n return RigidTransform(rotation=R_stp_camera,\n translation=t_stp_camera,\n from_frame='stp', to_frame='camera')","def testCalculateTransform(self):\n # Create some points in the first frame.\n z = 4.0\n self.evaluator.camera_height = z\n first_points = numpy.array(\n [[0, 0, z], [2, 0, z], [2, 5, z], [0, 5, z]], dtype=numpy.float32)\n # Create a transformation that will move the camera\n R = numpy.array([[0.0, -1.0, 0.0], [1.0, 0.0, 0.0], [0.0, 0.0, 1.0]])\n t = numpy.array([[3.0], [-5.0], [0.0]])\n expected_result = numpy.eye(4)\n expected_result[0:3, 0:3] = R\n expected_result[0:3, 3:] = t\n # Determine where the second points would be given that.\n second_points = (numpy.matmul(\n R, first_points.transpose()) + t).transpose()\n # Create a simple intrinsic matrix to project onto a fictional camera\n intrinsic = numpy.array(\n [[1.0, 0.0, 20.0], [0.0, 1.0, 20.0], [0.0, 0.0, 1.0]])\n # Use no distortion or transformations\n rvec = numpy.zeros((3, 1))\n tvec = rvec\n distortion = numpy.zeros((5, 1))\n # Project the points into the camera\n (camera_first_points, _) = cv2.projectPoints(\n first_points, rvec, tvec, intrinsic, distortion)\n camera_first_points = camera_first_points.squeeze()\n (camera_second_points, _) = cv2.projectPoints(\n second_points, rvec, tvec, intrinsic, distortion)\n camera_second_points = camera_second_points.squeeze()\n # Using these projected points, can the object recover the correct initial transform\n result = self.evaluator._calculateTransform(\n camera_first_points, camera_second_points, intrinsic)\n # The matrix comparisions aren't reliable near zero, so check elements manually.\n for i in range(expected_result.shape[0]):\n for j in range(expected_result.shape[1]):\n result_element = result[i, j]\n expected_element = expected_result[i, j]\n self.assertAlmostEqual(result_element, expected_element, 6,\n 'Matrix element ({0:d}, {1:d}) is incorrect.'.format(i, j))","def get_computed_camera_poses(self):\n pairs = sorted((timestamp, pose) for timestamp, pose in self.frame_deltas.items())\n current_pose = tf.Transform()\n computed_poses = {}\n for timestamp, delta in pairs:\n delta = delta.find_relative(tf.Transform()) # Flip the direction from previous pose relative to new\n current_pose = current_pose.find_independent(delta)\n computed_poses[timestamp] = current_pose\n return computed_poses","def CoordTrans(frame1, frame2, original_vec, oe=np.zeros(6), \n theta_gst=float('NaN'), lla_gs=np.zeros(3), mu=c.mu_earth, \n r_body=c.r_earth):\n\n # Orbital Elements\n a, e, inc, raan, w, nu = oe\n\n # Warnings\n oe_frames = ['ric', 'ntw', 'pqw']\n if any(frame in oe_frames for frame in (frame1, frame2)):\n if oe.dot(oe) == 0:\n print('ERROR: You forgot to define the orbital elements!')\n\n topocentric_frames = ['sez']\n if any(frame in topocentric_frames for frame in (frame1, frame2)):\n if lla_gs.dot(lla_gs) == 0:\n print('ERROR: You forgot lla for the ground stations!')\n\n # Coordinate System Logic\n if frame1.lower() == 'bci':\n if frame2.lower() == 'bcbf':\n rotated_vec = bci2bcbf(original_vec, theta_gst)\n if np.isnan(theta_gst):\n print('ERROR: You forgot to define theta_gst!')\n \n elif frame2.lower() == 'ric':\n rotated_vec = bci2ric(original_vec, raan, inc, w, nu)\n \n elif frame2.lower() == 'ntw':\n rotated_vec = bci2ntw(original_vec, e, raan, inc, w, nu)\n \n elif frame2.lower() == 'pqw':\n rotated_vec = bci2pqw(original_vec, raan, inc, w)\n \n elif frame2.lower() == 'lla':\n rotated_vec1 = bci2bcbf(original_vec, theta_gst)\n rotated_vec = bcbf2lla(rotated_vec1, r_body=r_body)\n if np.isnan(theta_gst):\n print('ERROR: You forgot to define theta_gst!')\n \n elif frame2.lower() == 'sez':\n rotated_vec1 = bci2bcbf(original_vec, theta_gst)\n rotated_vec = bcbf2sez(rotated_vec1, lla_gs, r_body=r_body)\n if np.isnan(theta_gst):\n print('ERROR: You forgot to define theta_gst!')\n\n else:\n print('ERROR: Frame2 is not included in this function!')\n\n elif frame1.lower() == 'bcbf':\n if frame2.lower() == 'bci':\n rotated_vec = bcbf2bci(original_vec, theta_gst)\n if np.isnan(theta_gst):\n print('ERROR: You forgot to define theta_gst!')\n \n elif frame2.lower() == 'ric':\n rotated_vec1 = bcbf2bci(original_vec, theta_gst)\n rotated_vec = bci2ric(rotated_vec1, raan, inc, w, nu)\n if np.isnan(theta_gst):\n print('ERROR: You forgot to define theta_gst!')\n \n elif frame2.lower() == 'ntw':\n rotated_vec1 = bcbf2bci(original_vec, theta_gst)\n rotated_vec = bci2ntw(rotated_vec1, e, raan, inc, w, nu)\n if np.isnan(theta_gst):\n print('ERROR: You forgot to define theta_gst!')\n \n elif frame2.lower() == 'pqw':\n rotated_vec1 = bcbf2bci(original_vec, theta_gst)\n rotated_vec = bci2pqw(rotated_vec1, raan, inc, w)\n if np.isnan(theta_gst):\n print('ERROR: You forgot to define theta_gst!')\n \n elif frame2.lower() == 'lla':\n rotated_vec = bcbf2lla(original_vec, r_body=r_body)\n \n elif frame2.lower() == 'sez':\n rotated_vec = bcbf2sez(original_vec, lla_gs, r_body=r_body)\n\n else:\n print('ERROR: Frame2 is not included in this function!')\n\n elif frame1.lower() == 'ric':\n rotated_vec1 = ric2bci(original_vec, raan, inc, w, nu)\n if frame2.lower() == 'bcbf':\n rotated_vec = bci2bcbf(rotated_vec1, theta_gst)\n if np.isnan(theta_gst):\n print('ERROR: You forgot to define theta_gst!')\n \n elif frame2.lower() == 'bci':\n rotated_vec = rotated_vec1\n \n elif frame2.lower() == 'ntw':\n rotated_vec = bci2ntw(rotated_vec1, e, raan, inc, w, nu)\n \n elif frame2.lower() == 'pqw':\n rotated_vec = bci2pqw(rotated_vec1, raan, inc, w)\n \n elif frame2.lower() == 'lla':\n rotated_vec2 = bci2bcbf(rotated_vec1, theta_gst)\n rotated_vec = bcbf2lla(rotated_vec2, r_body=r_body)\n if np.isnan(theta_gst):\n print('ERROR: You forgot to define theta_gst!')\n \n elif frame2.lower() == 'sez':\n rotated_vec2 = bci2bcbf(rotated_vec1, theta_gst)\n rotated_vec = bcbf2sez(rotated_vec2, lla_gs, r_body=r_body)\n if np.isnan(theta_gst):\n print('ERROR: You forgot to define theta_gst!')\n\n else:\n print('ERROR: Frame2 is not included in this function!')\n\n elif frame1.lower() == 'ntw':\n rotated_vec1 = ntw2bci(original_vec, e, raan, inc, w, nu)\n if frame2.lower() == 'bcbf':\n rotated_vec = bci2bcbf(rotated_vec1, theta_gst)\n if np.isnan(theta_gst):\n print('ERROR: You forgot to define theta_gst!')\n \n elif frame2.lower() == 'ric':\n rotated_vec = bci2ric(rotated_vec1, raan, inc, w, nu)\n \n elif frame2.lower() == 'bci':\n rotated_vec = rotated_vec1\n \n elif frame2.lower() == 'pqw':\n rotated_vec = bci2pqw(rotated_vec1, raan, inc, w)\n \n elif frame2.lower() == 'lla':\n rotated_vec2 = bci2bcbf(rotated_vec1, theta_gst)\n rotated_vec = bcbf2lla(rotated_vec2, r_body=r_body)\n if np.isnan(theta_gst):\n print('ERROR: You forgot to define theta_gst!')\n \n elif frame2.lower() == 'sez':\n rotated_vec2 = bci2bcbf(rotated_vec1, theta_gst)\n rotated_vec = bcbf2sez(rotated_vec2, lla_gs, r_body=r_body)\n if np.isnan(theta_gst):\n print('ERROR: You forgot to define theta_gst!')\n\n else:\n print('ERROR: Frame2 is not included in this function!')\n\n elif frame1.lower() == 'pqw':\n rotated_vec1 = pqw2bci(original_vec, raan, inc, w)\n if frame2.lower() == 'bcbf':\n rotated_vec = bci2bcbf(rotated_vec1, theta_gst)\n if np.isnan(theta_gst):\n print('ERROR: You forgot to define theta_gst!')\n \n elif frame2.lower() == 'ric':\n rotated_vec = bci2ric(rotated_vec1, raan, inc, w, nu)\n \n elif frame2.lower() == 'ntw':\n rotated_vec = bci2ntw(rotated_vec1, e, raan, inc, w, nu)\n \n elif frame2.lower() == 'bci':\n rotated_vec = rotated_vec1\n \n elif frame2.lower() == 'lla':\n rotated_vec2 = bci2bcbf(rotated_vec1, theta_gst)\n rotated_vec = bcbf2lla(rotated_vec2, r_body=r_body)\n if np.isnan(theta_gst):\n print('ERROR: You forgot to define theta_gst!')\n \n elif frame2.lower() == 'sez':\n rotated_vec2 = bci2bcbf(rotated_vec1, theta_gst)\n rotated_vec = bcbf2sez(rotated_vec2, lla_gs, r_body=r_body)\n if np.isnan(theta_gst):\n print('ERROR: You forgot to define theta_gst!')\n\n else:\n print('ERROR: Frame2 is not included in this function!')\n\n elif frame1.lower() == 'lla':\n rotated_vec1 = lla2bcbf(original_vec, r_body=r_body)\n if frame2.lower() == 'bcbf':\n rotated_vec = rotated_vec1\n \n elif frame2.lower() == 'ric':\n rotated_vec2 = bcbf2bci(rotated_vec1, theta_gst)\n rotated_vec = bci2ric(rotated_vec2, raan, inc, w, nu)\n if np.isnan(theta_gst):\n print('ERROR: You forgot to define theta_gst!')\n \n elif frame2.lower() == 'ntw':\n rotated_vec2 = bcbf2bci(rotated_vec1, theta_gst)\n rotated_vec = bci2ntw(rotated_vec2, e, raan, inc, w, nu)\n if np.isnan(theta_gst):\n print('ERROR: You forgot to define theta_gst!')\n \n elif frame2.lower() == 'pqw':\n rotated_vec2 = bcbf2bci(rotated_vec1, theta_gst)\n rotated_vec = bci2pqw(rotated_vec2, raan, inc, w)\n if np.isnan(theta_gst):\n print('ERROR: You forgot to define theta_gst!')\n \n elif frame2.lower() == 'bci':\n rotated_vec = bcbf2bci(rotated_vec1, theta_gst)\n if np.isnan(theta_gst):\n print('ERROR: You forgot to define theta_gst!')\n \n elif frame2.lower() == 'sez':\n rotated_vec = bcbf2sez(rotated_vec1, lla_gs, r_body=r_body)\n\n else:\n print('ERROR: Frame2 is not included in this function!')\n\n elif frame1.lower() == 'sez':\n rotated_vec1 = sez2bcbf(original_vec, lla_gs, r_body=r_body)\n rotated_vec2 = bcbf2bci(rotated_vec1, theta_gst)\n if np.isnan(theta_gst):\n print('ERROR: You forgot to define theta_gst!')\n \n if frame2.lower() == 'bcbf':\n rotated_vec = rotated_vec1\n \n elif frame2.lower() == 'ric':\n rotated_vec = bci2ric(rotated_vec2, raan, inc, w, nu)\n \n elif frame2.lower() == 'ntw':\n rotated_vec = bci2ntw(rotated_vec2, e, raan, inc, w, nu)\n \n elif frame2.lower() == 'pqw':\n rotated_vec = bci2pqw(rotated_vec2, raan, inc, w)\n \n elif frame2.lower() == 'lla':\n rotated_vec = bcbf2lla(rotated_vec1, r_body=r_body)\n \n elif frame2.lower() == 'bci':\n rotated_vec = rotated_vec2\n\n else:\n print('ERROR: Frame2 is not included in this function!')\n\n else:\n print('ERROR: Frame1 is not included in this function!')\n\n return rotated_vec","def compute_right_camera_pose(left_camera_to_world, left_to_right):\n left_world_to_camera = np.linalg.inv(left_camera_to_world)\n right_world_to_camera = np.matmul(left_to_right, left_world_to_camera)\n right_camera_to_world = np.linalg.inv(right_world_to_camera)\n return right_camera_to_world","def getMatrix(self, frame):\n self.matrix[3, 0]=self.getValue(frame)\n return self.matrix","def filter_rotation(frame):\n return frame[frame['direction'] != 'none'].copy()","def computeWorldTransformationFromFoot(self):\n self.corba.signal(self.perceivedBody).recompute(\n self.corba.signal(self.perceivedBody).time + 1)\n self.robot.dynamic.signal(\n self.trackedBody).recompute(self.robot.dynamic.signal(\n self.trackedBody).time + 1)\n\n mocapMfoot = XYThetaToHomogeneousMatrix(\n self.corba.signal(self.perceivedBody).value)\n sotMfoot = np.matrix(self.robot.dynamic.signal(\n self.trackedBody).value)\n\n # mocap position w.r.t sot frame\n sotMmocap = sotMfoot * np.linalg.inv(mocapMfoot)\n return matrixToTuple(sotMmocap)","def relative_pose_cam_to_body(\n relative_scene_pose, Rt_cam2_gt\n ):\n relative_scene_pose = (\n np.linalg.inv(Rt_cam2_gt)\n @ relative_scene_pose\n @ Rt_cam2_gt\n )\n return relative_scene_pose","def get_world_pose_for_camera_pose(self, pose):\n\n # Create a point stamped from the given position\n camera_point = geometry_msgs.msg.PointStamped()\n camera_point.header.stamp = rospy.Time.now()\n camera_point.header.frame_id = 'camera'\n camera_point.point.x = pose[0]\n camera_point.point.y = pose[1]\n camera_point.point.z = pose[2]\n\n # Wait for the transformation to be available\n time = rospy.Time().now()\n self.listener.waitForTransform('camera', 'world', time, rospy.Duration(5))\n world_point = self.listener.transformPoint('world', camera_point)\n\n # Return the new coordinates\n return [world_point.point.x, world_point.point.y, world_point.point.z]","def cam_to_world(cam_point, world_to_cam):\n # cam_point = np.array([cam_pose[0], cam_pose[1], cam_pose[2]])\n\n obj_vector = np.concatenate((cam_point, np.ones(1))).reshape((4, 1))\n world_point = np.dot(world_to_cam, obj_vector)\n\n world_point = [p[0] for p in world_point]\n return world_point[0:3]","def get_world_trans(m_obj):\n plug = get_world_matrix_plug(m_obj, 0)\n matrix_obj = plug.asMObject()\n matrix_data = oMa.MFnMatrixData(matrix_obj)\n matrix = matrix_data.matrix()\n\n trans_matrix = oMa.MTransformationMatrix(matrix)\n trans = trans_matrix.translation(oMa.MSpace.kWorld)\n\n return trans","def camera_matrix(e, p, t):\n # Translates all points such that the camera is centered at the origin.\n T = np.array([[1, 0, 0, -e[0]],\n [0, 1, 0, -e[1]],\n [0, 0, 1, -e[2]],\n [0, 0, 0, 1]])\n\n # Set up orthonormal basis.\n w = e - p\n w = w / np.linalg.norm(w)\n u = np.cross(t, w)\n u = u / np.linalg.norm(u)\n v = np.cross(w, u)\n\n # Rotate points such that camera is aligned with UVW-axes (g -> -z-axis).\n R = np.array([[u[0], u[1], u[2], 0],\n [v[0], v[1], v[2], 0],\n [w[0], w[1], w[2], 0],\n [ 0, 0, 0, 1]])\n return R.dot(T)","def get_render_obs(self):\n x, y, z = self.robot.body_xyz\n # print (x, y, z)\n cameraEyePosition = list([x, y-0.75, 1.0])\n cameraTargetPosition = [x, y, 1.0]\n cameraUpVector = [0, 0, 1]\n\n fov = 120\n aspect = self.render_dims[0] / self.render_dims[1]\n nearPlane = 0.05 # this ensures outside body, may see limbs\n farPlane = 100.0\n\n # TODO: fix me to be along moving axis\n viewMatrix = p.computeViewMatrix(cameraEyePosition, cameraTargetPosition, cameraUpVector, physicsClientId=self.physicsClientId)\n # viewMatrix = p.computeViewMatrixFromYawPitchRoll(camTargetPos, camDistance, yaw, pitch, roll, upAxisIndex)\n projectionMatrix = p.computeProjectionMatrixFOV(fov, aspect, nearPlane, farPlane);\n img_arr = p.getCameraImage(self.render_dims[0], self.render_dims[1], viewMatrix, projectionMatrix, renderer=p.ER_BULLET_HARDWARE_OPENGL, physicsClientId=self.physicsClientId)\n\n # w=img_arr[0] #width of the image, in pixels\n # h=img_arr[1] #height of the image, in pixels\n rgb=img_arr[2] #color data RGB\n gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)\n gray = gray.reshape((1, *self.render_dims))\n gray[gray > 0] = 255\n return gray","def getMatrix(self, frame):\n self.matrix[3, 2]=self.getValue(frame)\n return self.matrix","def getMatrix(self, frame):\n self.matrix[3, 1]=self.getValue(frame)\n return self.matrix","def camera_2_world(self, o, d):\r\n wo = self.camera2world_point @ ti.Vector([o.x, o.y, o.z, 1.0])\r\n wd = self.camera2world_vec @ d\r\n return ti.Vector([wo.x,wo.y,wo.z]), wd","def screenToCamera(self,x,y):\n #self.x = x\n #self.y = y\n new_x = x / (self.surf.get_width() - 1) - 0.5\n #-(new_x)\n new_y = y / (self.surf.get_height() - 1)\n new_y = (1.0 - cy) - 0.5\n new_z = -self.camNear\n formula = math3dsol.VectorN((new_x,new_y,new_z))\n return formula\n\n # FINISH ME!!!","def intrinsic_matrix_from_camera(w, h, fov):\n (cx, cy), f = calc_focal_values(w, h, fov)\n return np.array([[f, 0, cx], [0, f, cy], [0, 0, 1]])","def set_modelview_from_camera(Rt):\n \n glMatrixMode(GL_MODELVIEW)\n glLoadIdentity()\n \n # rotate teapot 90 deg around x-axis so that z-axis is up\n Rx = np.array([[1,0,0],[0,0,-1],[0,1,0]])\n \n # set rotation to best approximation\n R = Rt[:,:3]\n U,S,V = np.linalg.svd(R)\n R = np.dot(U,V)\n R[0,:] = -R[0,:] # change sign of x-axis\n \n # set translation\n t = Rt[:,3]\n \n # setup 4*4 model view matrix\n M = np.eye(4)\n M[:3,:3] = np.dot(R,Rx)\n M[:3,3] = t\n\n # transpose and flatten to get column order\n M = M.T\n \n m = M.flatten()\n \n # replace model view with the new matrix\n glLoadMatrixf(m)","def get_2d_poses(self, frame: int, camera: int) -> np.ndarray:\n poses = self._get_2d_data_by_type(frame, camera, 'poses')\n if frame in poses:\n return np.asarray(poses[frame])\n else:\n return np.array([])","def camera_coords_to_world_coords(point, cam_height, cam_angle):\n\n # adjust the axis order\n point = np.array([point[2], point[0], point[1]])\n\n # calculate the vectors of the camera axis in the desired coordinate system\n cam_direction = np.array([np.cos(cam_angle), 0, -np.sin(cam_angle)])\n z = cam_direction\n x = np.cross(np.array([0, 0, 1]), cam_direction)\n y = np.cross(z, x)\n\n # transposed rotation matrix\n rotation = np.vstack([x, y, z])\n\n # translation vector\n translation = np.array([0, 0, cam_height])\n\n return rotation @ (point - translation)","def get_render_obs(self):\n x, y, z = self.robot.body_xyz\n # print (x, y, z)\n\n if self.camera_type == 'follow':\n cameraEyePosition = [x, y-1.25, 1.0]\n cameraTargetPosition = [x, y, 1.0]\n elif self.camera_type == 'fixed':\n cameraEyePosition = [2.0, y-2.5, 1.0]\n cameraTargetPosition = [2.0, y, 1.0]\n\n cameraUpVector = [0, 0, 1]\n\n fov = 90\n aspect = self.render_dims[0] / self.render_dims[1]\n nearPlane = 0.05 # this ensures outside body, may see limbs\n farPlane = 100.0\n\n viewMatrix = p.computeViewMatrix(cameraEyePosition, cameraTargetPosition, cameraUpVector, physicsClientId=self.physicsClientId)\n projectionMatrix = p.computeProjectionMatrixFOV(fov, aspect, nearPlane, farPlane);\n img_arr = p.getCameraImage(self.render_dims[0], self.render_dims[1], viewMatrix, projectionMatrix, renderer=p.ER_BULLET_HARDWARE_OPENGL, physicsClientId=self.physicsClientId)\n\n rgb=img_arr[2] #color data RGB\n gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)\n gray = gray.reshape((1, *self.render_dims))\n gray[gray > 0] = 255\n\n # assign patch at bottom to show distance, this is to differentiate frames\n # bar_width_pix = int(y/5.0*self.render_dims[1])\n # bar_height_pix = 10\n # gray[0][self.render_dims[0]-bar_height_pix:, 0:bar_width_pix] = 255\n return gray","def get_camera(self, video: int, frame: int) -> Union[Camera, None]:\n params = self._get_calibration_params(video, frame)\n # Check if we found the camera parameters\n if not (params[0]):\n print(params[1])\n return\n else:\n params = params[1]\n \n # Construct the Camera object\n camera = Camera(params['K'], params['rvec'], params['tvec'], params['distCoef'], params['w'], params['h'])\n\n # Return the camera\n return camera","def get_projection_mapping(self, cam_pos, cam_rot, local_frame=False, range1=True):\n\n cam_pos = cam_pos.copy()\n cam_pos[2] += self.h_offset\n\n K = self.make_camera_matrix()\n R_opt = self.make_optical_rotation_matrix()\n T_opt = affines.compose([0, 0, 0], R_opt, [1.0, 1.0, 1.0])\n T_opt_inv = np.linalg.inv(T_opt)\n T = self.make_world_to_camera_mat(cam_pos, cam_rot)\n Tinv = np.linalg.inv(T)\n\n # Get the map position encodings (MxMx3)\n pts_w = self.get_world_coord_grid()[..., np.newaxis]\n\n # Get the coordinates in camera frame:\n if not local_frame:\n # If we're using a global map frame, transform the map coordinates into the camera frame\n pts_cam = np.matmul(Tinv[np.newaxis, ...], pts_w)\n else:\n # If we're using local frame, camera is centered in the map, but pitch must still be taken into account!\n # TODO: Fix this and add pitch\n pts_cam = pts_w\n pts_cam[:, 0:2] = pts_cam[:, 0:2] - self.map_world_size_px / 2\n\n # Get the coordinates in optical frame\n pts_opt = np.matmul(T_opt_inv[np.newaxis, ...], pts_cam)\n\n # Get the 3D coordinates of the map pixels in the image frame:\n pts_img = np.matmul(K[np.newaxis, ...], pts_opt[:, 0:3, :])\n\n # Convert to homogeneous (image-plane) coordinates\n valid_z = pts_img[:, 2:3, :] > 0\n\n pts_img = pts_img / (pts_img[:, 2:3] + 1e-9)\n #pts_img[:, 0] = pts_img[:, 0] / (pts_img[:, 2] + 1e-9)\n #pts_img[:, 1] = pts_img[:, 1] / (pts_img[:, 2] + 1e-9)\n\n # Mask out all the map elements that don't project on the image\n valid_y1 = pts_img[:, 0:1, :] > 0\n valid_y2 = pts_img[:, 0:1, :] < self.res_x\n valid_x1 = pts_img[:, 1:2, :] > 0\n valid_x2 = pts_img[:, 1:2, :] < self.res_y\n\n # Throw away the homogeneous Z coordinate\n pts_img = pts_img[:, 0:2]\n\n valid = valid_y1 * valid_y2 * valid_x1 * valid_x2 * valid_z\n\n # PyTorch takes projection mappings in -1 to 1 range:\n if range1:\n pts_img[:, 0] = (-pts_img[:, 0] + self.res_x / 2) / (self.res_x / 2)\n pts_img[:, 1] = (-pts_img[:, 1] + self.res_y / 2) / (self.res_y / 2)\n\n # Make sure the invalid points are out of range\n pts_img = pts_img * valid + 2 * np.ones_like(pts_img) * (1 - valid)\n else:\n pts_img = pts_img * valid\n\n # Remove the extra 1-length dimension\n pts_img = pts_img.squeeze()\n\n # Reshape into the 2D map representation\n pts_img = np.reshape(pts_img, [self.map_size_px, self.map_size_px, 2])\n\n return pts_img","def closest_approach_to_camera(scene, speaker_object) -> (float, int):\n max_dist = sys.float_info.max\n at_time = scene.frame_start\n for frame in range(scene.frame_start, scene.frame_end + 1):\n scene.frame_set(frame)\n rel = speaker_object.matrix_world.to_translation() - scene.camera.matrix_world.to_translation()\n dist = norm(rel)\n\n if dist < max_dist:\n max_dist = dist\n at_time = frame\n\n return max_dist, at_time","def adjust_camera(self):\n pose = deepcopy(self.data['poses']['marker']) # PoseStamped()\n eye_pose = deepcopy(pose)\n eye_pose.pose.position.x += 0.60\n eye_pose.pose.position.z += 0.20\n focus_pose = PoseStamped()\n base_eye_pose = PoseStamped()\n\n try:\n # Convert pose to base frame\n pose.header.stamp = self.tfl. \\\n getLatestCommonTime(self.params['world'], pose.header.frame_id)\n focus_pose = self.tfl.transformPose(self.params['world'], pose)\n except (TfE, LookupException, ConnectivityException):\n Me.error_message(\"Error transforming pose \" + pose.header.frame_id)\n\n try:\n # Convert pose to base frame\n pose.header.stamp = self.tfl. \\\n getLatestCommonTime(self.params['world'],\n eye_pose.header.frame_id)\n base_eye_pose = self.tfl.transformPose(self.params['world'],\n eye_pose)\n except (TfE, LookupException, ConnectivityException):\n Me.error_message(\"Error transforming pose \" + pose.header.frame_id)\n\n cam_place = CameraPlacement()\n cam_place.target_frame = self.params['world']\n cam_place.time_from_start = Duration(1)\n # Position of the camera relative to target_frame\n cam_place.eye.header.frame_id = cam_place.target_frame\n cam_place.eye.point = base_eye_pose.pose.position\n # Target_frame-relative point for the focus\n cam_place.focus.header.frame_id = cam_place.target_frame\n cam_place.focus.point = focus_pose.pose.position\n # Target_frame-relative vector that maps to \"up\" in the view plane.\n cam_place.up.header.frame_id = cam_place.target_frame\n cam_place.up.vector.x = 0\n cam_place.up.vector.y = 0\n cam_place.up.vector.z = 1\n self.pub.publish(cam_place)\n return","def camera_frame_directions(self) -> _BFRAME_TYPE:\n pass","def __init__(self, camera):\n self.__camera = camera\n self.__innerOrientationParameters = None\n self.__isSolved = False\n self.__exteriorOrientationParameters = np.array([0, 0, 0, 0, 0, 0], 'f')\n self.__rotationMatrix = None","def read(self):\r\n\t\t# get data from camera\r\n\t\tarray = self.ueye.get_data(self.pcImageMemory, self.width, self.height, self.nBitsPerPixel, self.pitch, copy=False)\r\n\t\t# get frame as numpy array\r\n\t\tframe = np.reshape(array,(self.height.value, self.width.value, self.bytes_per_pixel))\r\n\t\t\r\n\t\t\"\"\"\r\n\t\tcamera_matrix = np.array([\r\n\t\t\t[4.5330796457901283e+02, 0., 6.1902229288626302e+02],\r\n\t\t\t[0., 4.5369175559310276e+02, 5.1298362120979994e+02],\r\n\t\t\t[0., 0., 1.]])\r\n\t\t\r\n\t\tdist_coeffs = np.array([\r\n\t\t\t-3.1812973406286371e-01, 9.6396352148682182e-02,\r\n\t\t\t2.9601124432187590e-03, 9.7700591472463412e-04,\r\n\t\t\t-1.1929681608809075e-02\r\n\t\t])\r\n\r\n\t\tframe = cv2.undistort(frame, camera_matrix, dist_coeffs, camera_matrix)\r\n\t\t\"\"\"\r\n\r\n\t\treturn frame","def snapFrame(camera):\n return camera.read()[1]","def get_frame(self, camera: int = 0) -> Tuple[float, np.ndarray]:\n result = self.video.read()\n if result[0]:\n return result\n else: # If we reach the end of the video, go back to the beginning.\n self.video.set(cv2.CAP_PROP_POS_FRAMES, 0)\n return self.video.read()","def get_render_obs(self):\n x, y, z = self.robot.body_xyz\n\n if self.camera_type == 'follow':\n cameraEyePosition = [x, y-1.25, 1.0]\n cameraTargetPosition = [x, y, 1.0]\n elif self.camera_type == 'fixed':\n # y-2.7 not 2.5 since cheetah is longer\n cameraEyePosition = [2.0, y-2.7, 1.0]\n cameraTargetPosition = [2.0, y, 1.0]\n\n cameraUpVector = [0, 0, 1]\n\n fov = 90\n aspect = self.render_dims[0] / self.render_dims[1]\n nearPlane = 0.05 # this ensures outside body, may see limbs\n farPlane = 100.0\n\n viewMatrix = p.computeViewMatrix(cameraEyePosition, cameraTargetPosition, cameraUpVector, physicsClientId=self.physicsClientId)\n projectionMatrix = p.computeProjectionMatrixFOV(fov, aspect, nearPlane, farPlane);\n img_arr = p.getCameraImage(self.render_dims[0], self.render_dims[1], viewMatrix, projectionMatrix, renderer=p.ER_BULLET_HARDWARE_OPENGL, physicsClientId=self.physicsClientId)\n\n rgb=img_arr[2] #color data RGB\n gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)\n gray = gray.reshape((1, *self.render_dims))\n gray[gray > 0] = 255\n\n # assign patch at bottom to show distance, this is to differentiate frames\n # bar_width_pix = int(y/5.0*self.render_dims[1])\n # bar_height_pix = 10\n # gray[0][self.render_dims[0]-bar_height_pix:, 0:bar_width_pix] = 255\n return gray","def decompose_essential_matrix(E, x1, x2):\n\n # Fix left camera-matrix\n Rl = np.eye(3)\n tl = np.array([[0, 0, 0]]).T\n Pl = np.concatenate((Rl, tl), axis=1)\n\n # TODO: Compute possible rotations and translations\n \n # s must be [1, 1, 0]\n u, s, vh = np.linalg.svd(E)\n E = u @ np.diag([1, 1, 0]) @ vh\n u, s, vh = np.linalg.svd(E)\n\n w = np.array([[ 0, 1, 0], \n [-1, 0, 0], \n [ 0, 0, 1]]) \n \n z = np.array([[ 0, -1, 0], \n [ 1, 0, 0],\n [ 0, 0, 0]])\n \n R1 = u @ w.T @ vh\n s1 = -u @ z @ u.T\n R2 = u @ w @ vh\n s2 = u @ z @ u.T\n\n t1 = np.array([[s1[2, 1]], \n [s1[0, 2]],\n [s1[1, 0]]])\n \n t2 = np.array([[s2[2, 1]], \n [s2[0, 2]], \n [s2[1, 0]]]) \n\n # Four possibilities\n Pr = [np.concatenate((R1, t1), axis=1),\n np.concatenate((R1, t2), axis=1),\n np.concatenate((R2, t1), axis=1),\n np.concatenate((R2, t2), axis=1)]\n\n # Compute reconstructions for all possible right camera-matrices\n X3Ds = [infer_3d(x1[:, 0:1], x2[:, 0:1], Pl, x) for x in Pr]\n\n # Compute projections on image-planes and find when both cameras see point\n test = [np.prod(np.hstack((Pl @ np.vstack((X3Ds[i], [[1]])), Pr[i] @ np.vstack((X3Ds[i], [[1]])))) > 0, 1) for i in\n range(4)]\n test = np.array(test)\n idx = np.where(np.hstack((test[0, 2], test[1, 2], test[2, 2], test[3, 2])) > 0.)[0][0]\n\n # Choose correct matrix\n Pr = Pr[idx]\n\n return Pl, Pr","def r2n2_cam2world(self):\n if not hasattr(self, '_r2n2_cam2world'):\n ms = []\n for i in range(24):\n cam2v1 = assert_is_4x4(self.r2n2_cam2v1[i, ...])\n v12occnet = assert_is_4x4(self.v12occnet)\n occnet2gaps = assert_is_4x4(self.occnet2gaps)\n cam2occnet = np.matmul(v12occnet, cam2v1)\n cam2gaps = np.matmul(occnet2gaps, cam2occnet)\n ms.append(assert_is_4x4(cam2gaps))\n self._r2n2_cam2world = np.stack(ms).astype(np.float32)\n return self._r2n2_cam2world","def worldToCameraCentricXform(self):\n return self.rotateAlignXform().dot(self.translateToOriginXform())","def pixel2cam(self, depth, intrinsics_inv):\n b, _, h, w = depth.size()\n i_range = torch.arange(0, h).view(1, h, 1).expand(1,h,w).type_as(depth) # [1, H, W]\n j_range = torch.arange(0, w).view(1, 1, w).expand(1,h,w).type_as(depth) # [1, H, W]\n ones = torch.ones(1,h,w).type_as(depth)\n pixel_coords = torch.stack((j_range, i_range, ones), dim=1) # [1, 3, H, W]\n ###pixel_coords is an array of camera pixel coordinates (x,y,1) where x,y origin is the upper left corner of the image.\n current_pixel_coords = pixel_coords[:,:,:h,:w].expand(b,3,h,w).view(b,3,-1) #.contiguous().view(b, 3, -1) # [B, 3, H*W]\n #cam_coords = intrinsic_inv.expand(b,3,3).bmm(current_pixel_coords).view(b,3,h,w)\n cam_coords = intrinsics_inv.bmm(current_pixel_coords).view(b,3,h,w)\n return cam_coords * depth","def get_camera_orientation(self):\n\n # Create the vector from the camera to the robot\n vector_x = self.robot_x - self.camera_x\n vector_y = self.robot_y - self.camera_y\n vector_z = self.robot_z - self.camera_z\n\n # Calculate yaw and pitch from this vector\n yaw = math.atan2(vector_y, vector_x)\n pitch = -math.asin(vector_z)\n\n # Create the quaternion from the euler angles\n self.quaternion = geometry_msgs.msg.Quaternion(\n *tf_conversions.transformations.quaternion_from_euler(0, pitch, yaw))","def get_frame_root_rot(self, frame):\n root_rot = frame[self.POS_SIZE:(self.POS_SIZE + self.ROT_SIZE)].copy()\n return root_rot","def getDejaVuMatrix(self):\n mtx = self.getRotMatrix((4, 4), transpose=None) # from Quaternion\n mtx[3] = self.getTranslation()\n mtx[:3, 3] = mtx[3, :3]\n mtx[3, :3] = [0, 0, 0]\n return mtx","def translate_frame(frame, x, y):\n trans_mat = np.float32([[1, 0, x], [0, 1, y]])\n dimensions = (frame.shape[1], frame.shape[0])\n return cv.warpAffine(frame, trans_mat, dimensions)","def complex_camera(camera, target_rect):\n l, t, _, _ = target_rect\n _, _, w, h = camera\n l, t, _, _ = -l+300, -t+300, w, h\n\n l = min(0, l)\n l = max(-(camera.width-600), l)\n t = max(-(camera.height-600), t)\n t = min(0, t)\n\n return pygame.Rect(l, t, w, h)","def rotate_to_local(self,vxyz):\n return sp.mxv(self.mtxtofov,vxyz)","def get_image(self):\n self.flush_buffer()\n _, frame = self.cam.read()\n shift_frame = self.perspective_shift(frame)\n #shift_frame = None\n return frame, shift_frame","def get_transform(self, from_frame, to_frame):\n if not self._pipeline:\n return None\n try:\n from_ind = self._get_frame_index(from_frame)\n except ValueError:\n raise CoordinateFrameError(\"Frame {0} is not in the available \"\n \"frames\".format(from_frame))\n try:\n to_ind = self._get_frame_index(to_frame)\n except ValueError:\n raise CoordinateFrameError(\"Frame {0} is not in the available frames\".format(to_frame))\n if to_ind < from_ind:\n #transforms = np.array(self._pipeline[to_ind: from_ind], dtype=\"object\")[:, 1].tolist()\n transforms = [step.transform for step in self._pipeline[to_ind: from_ind]]\n transforms = [tr.inverse for tr in transforms[::-1]]\n elif to_ind == from_ind:\n return None\n else:\n #transforms = np.array(self._pipeline[from_ind: to_ind], dtype=\"object\")[:, 1].copy()\n transforms = [step.transform for step in self._pipeline[from_ind: to_ind]]\n return functools.reduce(lambda x, y: x | y, transforms)","def extract_camera_sync(sync, chmap=None):\n assert(chmap)\n sr = _get_sync_fronts(sync, chmap['right_camera'])\n sl = _get_sync_fronts(sync, chmap['left_camera'])\n sb = _get_sync_fronts(sync, chmap['body_camera'])\n return {'right': sr.times[::2],\n 'left': sl.times[::2],\n 'body': sb.times[::2]}","def get_projection_matrix(self, aspect):\n return self.ptr.get_projection_matrix(aspect)","def determine_rotation_matrix(self, origin, angle, scale):\n # scaling will be ignored at this step\n rotation_matrix = cv2.getRotationMatrix2D(origin, angle * 180 / np.pi, scale)\n return rotation_matrix","def get_frame(self, camera: int = 0) -> Tuple[float, np.ndarray]:\n return self.video.read()","def simple_camera(camera, target_rect):\n l, t, _, _ = target_rect\n _, _, w, h = camera\n return pygame.Rect(-l+300, -t+300, w, h)","def get_frame_joints_vel(self, frame):\n vel = frame[(self.VEL_SIZE + self.ANG_VEL_SIZE):].copy()\n return vel","def _omni_frame_to_omni_frame_projection(self, agent_rel_pose, agent_rel_mat, uniform_sphere_pixel_coords,\n sphere_pix_coords_f1, sphere_depth_f1, sphere_feat_f1, agent_rel_pose_cov,\n image_var_f1, holes_prior, holes_prior_var, batch_size):\n\n # Frame 1 #\n # --------#\n\n # combined\n\n # B x OH x OW x 3\n angular_pixel_coords_f1 = ivy.concatenate((sphere_pix_coords_f1, sphere_depth_f1), -1)\n\n # sphere coords\n\n # B x OH x OW x 3\n sphere_coords_f1 = \\\n ivy_vision.angular_pixel_to_sphere_coords(angular_pixel_coords_f1, self._pixels_per_degree)\n\n # Frame 2 #\n # --------#\n\n # sphere to sphere pixel projection\n\n sphere_coords_f2 = ivy_vision.sphere_to_sphere_coords(\n sphere_coords_f1, agent_rel_mat, [batch_size], self._sphere_img_dims)\n image_var_f2 = image_var_f1\n\n # to angular pixel coords\n\n # B x OH x OW x 3\n angular_pixel_coords_f2 = \\\n ivy_vision.sphere_to_angular_pixel_coords(sphere_coords_f2, self._pixels_per_degree)\n\n # constant feature projection\n\n # B x OH x OW x (3+F)\n projected_coords_f2 = ivy.concatenate([angular_pixel_coords_f2] + [sphere_feat_f1], -1)\n\n # reshaping to fit quantization dimension requirements\n\n # B x (OHxOW) x (3+F)\n projected_coords_f2_flat = ivy.reshape(projected_coords_f2,\n [batch_size] + [self._sphere_img_dims[0] * self._sphere_img_dims[1]]\n + [3 + self._feat_dim])\n\n # B x (OHxOW) x (3+F)\n image_var_f2_flat = ivy.reshape(image_var_f2,\n [batch_size] + [self._sphere_img_dims[0] * self._sphere_img_dims[1]]\n + [3 + self._feat_dim])\n\n # quantize the projection\n\n # B x N x OH x OW x (3+F) # B x N x OH x OW x (3+F)\n return ivy_vision.quantize_to_image(\n pixel_coords=projected_coords_f2_flat[..., 0:2],\n final_image_dims=self._sphere_img_dims,\n feat=projected_coords_f2_flat[..., 2:],\n feat_prior=holes_prior,\n with_db=self._with_depth_buffer,\n pixel_coords_var=image_var_f2_flat[..., 0:2],\n feat_var=image_var_f2_flat[..., 2:],\n pixel_coords_prior_var=holes_prior_var[..., 0:2],\n feat_prior_var=holes_prior_var[..., 2:],\n var_threshold=self._var_threshold[:, 0],\n uniform_pixel_coords=uniform_sphere_pixel_coords,\n batch_shape=(batch_size,),\n dev_str=self._dev_str)[0:2]","def gen_locate_camera_frame(self, exp_id, left_cam_id, right_cam_id, frame_id):\n exp = experiment.experiment(new_experiment=False, ts=str(exp_id))\n room_name = exp.metadata[\"room\"]\n if room_name.lower() == \"cears\":\n room_id = 1\n elif room_name.lower() == \"computer_lab\":\n room_id = 0\n\n devices = self.rooms[room_id][\"devices\"]\n devices.sort()\n\n fname = str(frame_id) + \".png\"\n\n l_camera_name = os.path.basename(devices[int(left_cam_id)])\n r_camera_name = os.path.basename(devices[int(right_cam_id)])\n\n path_l = os.path.join(self.um.experiment_path(exp_id), \"raw\", l_camera_name, fname) # noqa: E501\n\n path_r = os.path.join(self.um.experiment_path(exp_id), \"raw\", r_camera_name, fname) # noqa: E501\n\n frame_l = cv2.imread(path_l, )\n frame_r = cv2.imread(path_r, )\n\n retval = True\n\n if frame_l is None:\n frame_l = cv2.imread(\"flask_app/static/task.jpg\")\n ret_val = False\n\n if frame_r is None:\n frame_r = cv2.imread(\"flask_app/static/task.jpg\")\n ret_val = False\n\n pattern_shape = (9, 6) # TODO: CHECK THIS\n grid_size = 30 # TODO: CHECK THIS\n text_l, corners_l, canvas_l, R_l, t_l = computer_vision.calculate_camera_pose(frame_l, self.K, self.d, pattern_shape=pattern_shape, grid_size=grid_size) # noqa: E501\n text_r, corners_r, canvas_r, R_r, t_r = computer_vision.calculate_camera_pose(frame_r, self.K, self.d, pattern_shape=pattern_shape, grid_size=grid_size) # noqa: E501\n \n T_l = np.eye(4)\n T_r = np.eye(4)\n if R_l is not None and R_r is not None:\n T_l[0:3, 0:3] = R_l\n T_r[0:3, 0:3] = R_r\n T_l[0:3, 3] = t_l.ravel()\n T_r[0:3, 3] = t_r.ravel()\n\n T_l = np.eye(4)\n T_r = np.linalg.inv(T_l).dot(T_r)\n\n print T_l\n print T_r\n canvas = np.hstack([canvas_l, canvas_r])\n\n text = \"Left: \" + text_l + \" Right: \" + text_r\n cv2.putText(canvas, text, (20, 40), cv2.FONT_HERSHEY_SIMPLEX,\n 1.0, (0, 0, 255), lineType=cv2.LINE_AA)\n\n ret, jpeg = cv2.imencode('.jpg', canvas)\n\n if ret:\n img = jpeg.tobytes()\n else:\n pass\n\n yield (b'--frame\\r\\n'\n b'Content-Type: image/png;base64,\\r\\n\\r\\n' + img + b'\\r\\n')","def get_bounding_boxes(vehicles, camera):\n '''\n bounding_boxes = np.array([ClientSideBoundingBoxes.get_bounding_box(vehicle, camera) for vehicle in vehicles])\n # filter objects behind camera\n inscene_indices = np.array([1 if all(bb[:, 2]) > 0 else 0 for bb in bounding_boxes])\n inscene_indices = np.argwhere(inscene_indices == 1)\n bounding_boxes_visible = [bb for ]\n rotations = [vehicle.get_transform().rotation for vehicle in vehicles]\n rotation_decomposed = np.array([[rotation.yaw, rotation.roll, rotation.pitch] for rotation in rotations])\n rotations_visible = rotation_decomposed[inscene_indices]\n return bounding_boxes_visible, rotations_visible\n '''\n bounding_boxes = [ClientSideBoundingBoxes.get_bounding_box(vehicle, camera) for vehicle in vehicles]\n # filter objects behind camera\n rotations = []\n for vehicle in vehicles:\n transform = vehicle.get_transform()\n rotation = transform.rotation\n rotations.append([rotation.yaw, rotation.roll, rotation.pitch])\n inscene_indices = []\n for i in range(len(bounding_boxes)):\n bb = bounding_boxes[i]\n if all(bb[:, 2] > 0):\n inscene_indices.append(1)\n else:\n inscene_indices.append(0) \n inscene_boxes = [bounding_boxes[i] for i in range(len(bounding_boxes)) if inscene_indices[i] == 1]\n return inscene_boxes, np.array(rotations)[inscene_indices]","def getLocalTransform(animation, jointlock, frame, pointpos, handthick = 3.5):\n jointTransform = jointlock.getGlobalTransform(frame)\n if handthick:\n jointPosition = np.dot(jointTransform,[0,0,0,1])[:-1]\n #Find parametric equation to remove hands surface (hand thickness)\n vec = jointPosition - pointpos\n distance = np.linalg.norm(vec)\n t = handthick/distance\n position = pointpos + t*vec\n else:\n position = pointpos\n jointInverse = mathutils.inverseMatrix(jointTransform)\n globalTransform = mathutils.matrixTranslation(position[0], position[1], position[2])\n localTransform = np.dot(jointInverse, globalTransform)\n return localTransform","def get_camera_stationary_frame_difference_skeleton(threshold, sampling_rate):\n return {\n 'result': [],\n 'hyperparameters': {\n 'threshold': threshold,\n 'sampling_rate': sampling_rate\n }\n }","def get_matrix(transform):\n\n rotation = transform.rotation\n location = transform.location\n c_y = np.cos(np.radians(rotation.yaw))\n s_y = np.sin(np.radians(rotation.yaw))\n c_r = np.cos(np.radians(rotation.roll))\n s_r = np.sin(np.radians(rotation.roll))\n c_p = np.cos(np.radians(rotation.pitch))\n s_p = np.sin(np.radians(rotation.pitch))\n matrix = np.matrix(np.identity(4))\n matrix[0, 3] = location.x\n matrix[1, 3] = location.y\n matrix[2, 3] = location.z\n matrix[0, 0] = c_p * c_y\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\n matrix[1, 0] = s_y * c_p\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\n matrix[2, 0] = s_p\n matrix[2, 1] = -c_p * s_r\n matrix[2, 2] = c_p * c_r\n\n origin = np.array([location.x, location.y, location.z])\n return matrix, origin","def proj_to_velo(calib_data):\n rect = calib_data[\"R0_rect\"].reshape(3, 3)\n velo_to_cam = calib_data[\"Tr_velo_to_cam\"].reshape(3, 4)\n inv_rect = np.linalg.inv(rect)\n inv_velo_to_cam = np.linalg.pinv(velo_to_cam[:, :3])\n return np.dot(inv_velo_to_cam, inv_rect)","def video(perspective_matrix_path, source=\"cam\", save=False, save_path=None, file_name=\"out\", cam_cal=None):\n if not os.path.isfile(perspective_matrix_path):\n raise FileNotFoundError(\"Path to perspective matrix file not exist!\")\n\n with open(perspective_matrix_path, \"rb\") as p:\n perspective_matrix = pickle.load(p)\n M = perspective_matrix[\"M\"]\n Minv = perspective_matrix[\"Minv\"]\n\n if source == \"cam\":\n cap = cv2.VideoCapture(0)\n else:\n if not os.path.isfile(source):\n raise FileNotFoundError(source, \" not Exist!\")\n cap = cv2.VideoCapture(source)\n\n # camera calibration parameters [ mtx , dist]\n mtx = None\n dist = None\n\n out = None\n if save:\n if not os.path.isdir(save_path):\n raise FileNotFoundError(save_path, \" Not Exist!\")\n file_name += \".mp4\"\n out = cv2.VideoWriter(save_path + file_name, -1, 20, (int(cap.get(3)), int(cap.get(4))))\n\n if cam_cal:\n if not os.path.isfile(cam_cal):\n raise FileNotFoundError(cam_cal, \" Not Exist!\")\n\n with open(cam_cal, \"rb\") as p:\n calibration = pickle.load(p)\n mtx = calibration[\"mtx\"]\n dist = calibration[\"dist\"]\n\n left_line = Line(5)\n right_line = Line(5)\n\n while True:\n # Capture frame-by-frame\n ret, frame = cap.read()\n if not ret:\n print(\"Finished..\")\n sys.exit(0)\n\n # cv2 read frame as BGR, convert it to RGB\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n\n # camera calibration\n if not (mtx is None or dist is None):\n frame = cv2.undistort(frame, mtx, dist, None, mtx)\n\n # get edges in image\n edges = apply_edge_detection(frame)\n\n # transform image to bird view\n warped = warped_img(edges, M)\n\n # init out image which will draw lane line on it then weight it with original frame\n out_img = np.zeros_like(warped)\n if len(warped.shape) == 3 and warped.shape[2] == 3:\n pass\n else:\n out_img = np.dstack((out_img, out_img, out_img))\n\n # if line not detected, apply sliding window\n if not left_line.detected or not right_line.detected:\n leftx, lefty, rightx, righty = sliding_window(warped, 9, 200)\n\n # if already detected apply search around detected line\n else:\n leftx, lefty = search_around_poly(left_line, warped)\n rightx, righty = search_around_poly(right_line, warped)\n\n # will used for plotting line, find x fitted\n ploty = np.linspace(warped.shape[0] // 4, warped.shape[0] - 1, warped.shape[0])\n\n # check if at least 100 pixels detected as line\n if len(leftx) > 100 and len(rightx) > 100:\n\n # make detected flag true\n left_line.detected = True\n right_line.detected = True\n\n left_line.current_x = leftx\n left_line.current_y = lefty\n\n right_line.current_x = rightx\n right_line.current_y = righty\n\n left_line.fit_polynomial(ploty)\n right_line.fit_polynomial(ploty)\n\n else:\n print(\"Line not detected in this frame \")\n # we just draw line form previous frame\n\n # make detected flag true\n left_line.detected = False\n right_line.detected = False\n\n # update Lane line radius\n left_line.radius()\n right_line.radius()\n\n # avg radius of to lines, and plot it\n radius = (left_line.radius_of_curvature + right_line.radius_of_curvature) // 2\n frame = write_text(frame, \"Radius of Curvature = \" + str(radius) + \" M\", pos=(20, 50))\n\n # calculate Alignment ( how much car away from center between Lane lines\n dir = \"Left\" # car far from left or right\n\n left_line.car_offset(frame.shape) # distance from left line\n right_line.car_offset(frame.shape) # distance from right line\n\n distance = round(right_line.line_base_pos - left_line.line_base_pos, 2)\n\n if distance < 0: # car far away from left line not right line\n distance = -distance\n dir = \"Right\"\n frame = write_text(frame, \"Vehicle is {}m {} of center\".format(distance, dir), pos=(20, 80))\n\n # ** plot lane lines on image **\n # left_line.draw_line(out_img, ploty)\n # right_line.draw_line(out_img, ploty)\n\n # color pixel which belong to lane lines\n left_line.color_pixel(out_img, (255, 0, 0))\n right_line.color_pixel(out_img, (255, 100, 0))\n\n # fit green triangle in area between lane lines\n pts_left = np.array([np.transpose(np.vstack([left_line.bestx, ploty]))])\n pts_right = np.array([np.flipud(np.transpose(np.vstack([right_line.bestx, ploty])))])\n pts = np.hstack((pts_left, pts_right))\n\n # Draw the lane onto the warped blank image\n cv2.fillPoly(out_img, np.int_([pts]), (0, 255, 0))\n\n # return image to normal view from bird view\n out_img_undit = warped_img(out_img, Minv)\n\n # weight out_image_undit with original frame\n frame = cv2.addWeighted(out_img_undit, 0.5, frame, 1, 0)\n frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)\n\n cv2.imshow(\"frame\", frame)\n\n # write video\n if save:\n out.write(frame)\n if cv2.waitKey(1) & 0xFF == ord('q'):\n break\n\n # When everything done, release the capture\n cap.release()\n cv2.destroyAllWindows()","def base_projection_matrix(self, fiber):\n return matrix(ZZ, fiber.vertices()).right_kernel_matrix()","def get_world_rot(m_obj):\n plug = get_world_matrix_plug(m_obj, 0)\n matrix_obj = plug.asMObject()\n matrix_data = oMa.MFnMatrixData(matrix_obj)\n matrix = matrix_data.matrix()\n\n trans_matrix = oMa.MTransformationMatrix(matrix)\n rot = trans_matrix.rotation()\n\n return rot","def transform(orbit, frame_orig, frame_dest):\n\n orbit_orig = frame_orig(\n x=orbit.r[0],\n y=orbit.r[1],\n z=orbit.r[2],\n v_x=orbit.v[0],\n v_y=orbit.v[1],\n v_z=orbit.v[2],\n representation=CartesianRepresentation,\n differential_type=CartesianDifferential,\n )\n\n orbit_dest = orbit_orig.transform_to(frame_dest(obstime=orbit.epoch))\n orbit_dest.representation = CartesianRepresentation\n\n return Orbit.from_vectors(\n orbit.attractor,\n orbit_dest.data.xyz,\n orbit_dest.data.differentials[\"s\"].d_xyz,\n epoch=orbit.epoch,\n )","def calc_transform(src_, dst_):\n M_ = cv2.getPerspectiveTransform(src_, dst_)\n Minv_ = cv2.getPerspectiveTransform(dst_, src_)\n return M_, Minv_","def copy(self):\n return CameraExtrinsic(self.position, self.direction, self.up)","def __parseFrameSpherical(self):\n print(\"pointcloud: starting the frame parsing\")\n pointArray = []\n for (y, row) in enumerate(self.frame):\n #trim hfov\n pixelWidth = len(row)\n deltaAngle = self.rawhfov - self.desiredhfov\n pixelsToRemove = pixelWidth / deltaAngle \n row = row[int(ceil(pixelsToRemove/2)) : pixelWidth-int(ceil(pixelsToRemove/2)) ]\n \n for x, depth in enumerate(row):\n if(depth == 0):\n continue\n width = float(len(row))\n height = float(len(self.frame))\n thetax = (pi/2) - radians((self.rawhfov / width) * x)\n thetay = (pi/2) - radians((self.vfov / height) * y)\n vx = float(cos(thetax) * sin(thetay) * depth)\n vy = float(sin(thetax) * sin(thetay) * depth)\n vz = float(cos(thetay) * depth)\n vector3 = [vx, vy, vz]\n pointArray.append(vector3)\n self.points = pointArray\n print(\"pointcloud: ended the frame parsing\")","def cam_to_body(self, vector):\n cam2hand = generate_frame_transform(self._cam2hand_t[0:3,:],self._cam2hand_R[0:3,0:3],False)\n # Possibly GRASP specific function?\n hand_pose = baxter.get_right_arm_pose()\n (t,R) = get_t_R(hand_pose)\n hand2body = generate_frame_transform(t[0:3,:],R[0:3,0:3],True)\n return np.dot(hand2body,np.dot(cam2hand,vector))","def _frame_to_omni_frame_projection(self, cam_rel_poses, cam_rel_mats, uniform_sphere_pixel_coords, cam_coords_f1,\n cam_feat_f1, rel_pose_covs, image_var_f1, holes_prior, holes_prior_var,\n batch_size, num_timesteps, num_cams, image_dims):\n\n # cam 1 to cam 2 coords\n\n cam_coords_f2 = ivy_vision.cam_to_cam_coords(\n ivy_mech.make_coordinates_homogeneous(\n cam_coords_f1, [batch_size, num_timesteps, num_cams] + image_dims), cam_rel_mats,\n [batch_size, num_timesteps, num_cams], image_dims)\n\n # cam 2 to sphere 2 coords\n\n sphere_coords_f2 = ivy_vision.cam_to_sphere_coords(cam_coords_f2)\n image_var_f2 = image_var_f1\n\n # angular pixel coords\n\n # B x N x C x H x W x 3\n angular_pixel_coords_f2 = \\\n ivy_vision.sphere_to_angular_pixel_coords(sphere_coords_f2, self._pixels_per_degree)\n\n # constant feature projection\n\n # B x N x C x H x W x (3+F)\n projected_coords_f2 = ivy.concatenate([angular_pixel_coords_f2] + [cam_feat_f1], -1)\n\n # reshaping to fit quantization dimension requirements\n\n # B x N x (CxHxW) x (3+F)\n projected_coords_f2_flat = \\\n ivy.reshape(projected_coords_f2,\n [batch_size, num_timesteps, num_cams * image_dims[0] * image_dims[1], -1])\n\n # B x N x (CxHxW) x (3+F)\n image_var_f2_flat = ivy.reshape(image_var_f2,\n [batch_size, num_timesteps, num_cams * image_dims[0] * image_dims[1], -1])\n\n # quantized result from all scene cameras\n\n # B x N x OH x OW x (3+F) # B x N x OH x OW x (3+F)\n return ivy_vision.quantize_to_image(\n pixel_coords=projected_coords_f2_flat[..., 0:2],\n final_image_dims=self._sphere_img_dims,\n feat=projected_coords_f2_flat[..., 2:],\n feat_prior=holes_prior,\n with_db=self._with_depth_buffer,\n pixel_coords_var=image_var_f2_flat[..., 0:2],\n feat_var=image_var_f2_flat[..., 2:],\n pixel_coords_prior_var=holes_prior_var[..., 0:2],\n feat_prior_var=holes_prior_var[..., 2:],\n var_threshold=self._var_threshold,\n uniform_pixel_coords=uniform_sphere_pixel_coords,\n batch_shape=(batch_size, num_timesteps),\n dev_str=self._dev_str)[0:2]","def projection_matrix(self):\n scene = self.figure.scene\n scene_size = tuple(scene.get_size())\n aspect_ratio = float(scene_size[0]) / float(scene_size[1])\n p = scene.camera.get_perspective_transform_matrix(\n aspect_ratio, -1, 1).to_array().astype(np.float32)\n return p","def get_M(self, theta, phi, gamma, dx, dy, dz):\n w = self.width\n h = self.height\n f = self.focal\n # Projection 2D -> 3D matrix\n A1 = np.array([[1, 0, -w / 2],\n [0, 1, -h / 2],\n [0, 0, 1],\n [0, 0, 1]])\n # Rotation matrices around the X, Y, and Z axis\n RX = np.array([[1, 0, 0, 0],\n [0, np.cos(theta), -np.sin(theta), 0],\n [0, np.sin(theta), np.cos(theta), 0],\n [0, 0, 0, 1]])\n RY = np.array([[np.cos(phi), 0, -np.sin(phi), 0],\n [0, 1, 0, 0],\n [np.sin(phi), 0, np.cos(phi), 0],\n [0, 0, 0, 1]])\n RZ = np.array([[np.cos(gamma), -np.sin(gamma), 0, 0],\n [np.sin(gamma), np.cos(gamma), 0, 0],\n [0, 0, 1, 0],\n [0, 0, 0, 1]])\n # Composed rotation matrix with (RX, RY, RZ)\n R = np.dot(np.dot(RX, RY), RZ)\n # Translation matrix\n T = np.array([[1, 0, 0, dx],\n [0, 1, 0, dy],\n [0, 0, 1, dz],\n [0, 0, 0, 1]])\n # Projection 3D -> 2D matrix\n A2 = np.array([[f, 0, w / 2, 0],\n [0, f, h / 2, 0],\n [0, 0, 1, 0]])\n # Final transformation matrix\n return np.dot(A2, np.dot(T, np.dot(R, A1)))","def export_camera(file, scene, global_matrix, render, tab_write):\n camera = scene.camera\n\n # DH disabled for now, this isn't the correct context\n active_object = None # bpy.context.active_object # does not always work MR\n matrix = global_matrix @ camera.matrix_world\n focal_point = camera.data.dof.focus_distance\n\n # compute resolution\n q_size = render.resolution_x / render.resolution_y\n tab_write(file, \"#declare camLocation = <%.6f, %.6f, %.6f>;\\n\" % matrix.translation[:])\n tab_write(\n file,\n (\n \"#declare camLookAt = <%.6f, %.6f, %.6f>;\\n\"\n % tuple(degrees(e) for e in matrix.to_3x3().to_euler())\n ),\n )\n\n tab_write(file, \"camera {\\n\")\n if scene.pov.baking_enable and active_object and active_object.type == \"MESH\":\n tab_write(file, \"mesh_camera{ 1 3\\n\") # distribution 3 is what we want here\n tab_write(file, \"mesh{%s}\\n\" % active_object.name)\n tab_write(file, \"}\\n\")\n tab_write(file, \"location <0,0,.01>\")\n tab_write(file, \"direction <0,0,-1>\")\n\n else:\n if camera.data.type == \"ORTHO\":\n # XXX todo: track when SensorHeightRatio was added to see if needed (not used)\n sensor_height_ratio = (\n render.resolution_x * camera.data.ortho_scale / render.resolution_y\n )\n tab_write(file, \"orthographic\\n\")\n # Blender angle is radian so should be converted to degrees:\n # % (camera.data.angle * (180.0 / pi) )\n # but actually argument is not compulsory after angle in pov ortho mode\n tab_write(file, \"angle\\n\")\n tab_write(file, \"right <%6f, 0, 0>\\n\" % -camera.data.ortho_scale)\n tab_write(file, \"location <0, 0, 0>\\n\")\n tab_write(file, \"look_at <0, 0, -1>\\n\")\n tab_write(file, \"up <0, %6f, 0>\\n\" % (camera.data.ortho_scale / q_size))\n\n elif camera.data.type == \"PANO\":\n tab_write(file, \"panoramic\\n\")\n tab_write(file, \"location <0, 0, 0>\\n\")\n tab_write(file, \"look_at <0, 0, -1>\\n\")\n tab_write(file, \"right <%s, 0, 0>\\n\" % -q_size)\n tab_write(file, \"up <0, 1, 0>\\n\")\n tab_write(file, \"angle %f\\n\" % (360.0 * atan(16.0 / camera.data.lens) / pi))\n elif camera.data.type == \"PERSP\":\n # Standard camera otherwise would be default in pov\n tab_write(file, \"location <0, 0, 0>\\n\")\n tab_write(file, \"look_at <0, 0, -1>\\n\")\n tab_write(file, \"right <%s, 0, 0>\\n\" % -q_size)\n tab_write(file, \"up <0, 1, 0>\\n\")\n tab_write(\n file,\n \"angle %f\\n\"\n % (2 * atan(camera.data.sensor_width / 2 / camera.data.lens) * 180.0 / pi),\n )\n\n tab_write(\n file,\n \"rotate <%.6f, %.6f, %.6f>\\n\" % tuple(degrees(e) for e in matrix.to_3x3().to_euler()),\n )\n\n tab_write(file, \"translate <%.6f, %.6f, %.6f>\\n\" % matrix.translation[:])\n if camera.data.dof.use_dof and (focal_point != 0 or camera.data.dof.focus_object):\n tab_write(\n file, \"aperture %.3g\\n\" % (1 / (camera.data.dof.aperture_fstop * 10000) * 1000)\n )\n tab_write(\n file,\n \"blur_samples %d %d\\n\"\n % (camera.data.pov.dof_samples_min, camera.data.pov.dof_samples_max),\n )\n tab_write(file, \"variance 1/%d\\n\" % camera.data.pov.dof_variance)\n tab_write(file, \"confidence %.3g\\n\" % camera.data.pov.dof_confidence)\n if camera.data.dof.focus_object:\n focal_ob = scene.objects[camera.data.dof.focus_object.name]\n matrix_blur = global_matrix @ focal_ob.matrix_world\n tab_write(file, \"focal_point <%.4f,%.4f,%.4f>\\n\" % matrix_blur.translation[:])\n else:\n tab_write(file, \"focal_point <0, 0, %f>\\n\" % focal_point)\n if camera.data.pov.normal_enable:\n tab_write(\n file,\n \"normal {%s %.4f turbulence %.4f scale %.4f}\\n\"\n % (\n camera.data.pov.normal_patterns,\n camera.data.pov.cam_normal,\n camera.data.pov.turbulence,\n camera.data.pov.scale,\n ),\n )\n tab_write(file, \"}\\n\")","def _calculate_camera_array(self):\n look_list = []\n\n row_step_vec = normalize(self.look_up) * self.interspatial_distance\n col_step_vec = self._get_look_right() * self.interspatial_distance\n\n # Start at the top left camera position\n for i in range(self.spatial_rows):\n row_movement = row_step_vec * (-i)\n row_look_from = self.look_from + row_movement\n row_look_to = self.look_to + row_movement\n\n for j in range(self.spatial_cols):\n col_movement = col_step_vec * j\n cam_look_from = row_look_from + col_movement\n cam_look_to = row_look_to + col_movement\n\n look_list.append((cam_look_from, cam_look_to))\n\n return look_list","def publish_camera_frame(self):\n executive.get_camera_orientation()\n self.t.start()\n # Wait for transformation to be published\n rospy.sleep(2)","def perspective_transform():\n src = np.float32([(220,720), (1110, 720), (570, 470), (722, 470)]) # Manually get these numbers from plot\n dst = np.float32([[320, 720], [920, 720], [320, 1], [920, 1]])\n M = cv2.getPerspectiveTransform(src, dst)\n Minv = cv2.getPerspectiveTransform(dst, src)\n\n return M, Minv","def _calculate_camera_pose(frame, K, d, corners, pattern_shape=(6, 4), grid_size=30): # noqa: E501\n img = frame.copy()\n axis = np.float32([[grid_size, 0, 0], [0, grid_size, 0],\n [0, 0, -grid_size]]).reshape(-1, 3)*2\n\n objp = np.zeros((np.prod(pattern_shape), 3), np.float32)\n objp[:, :2] = np.mgrid[0:pattern_shape[0],\n 0:pattern_shape[1]].T.reshape(-1, 2) * grid_size\n\n _, rvecs, tvecs = cv2.solvePnP(objp, corners, K, d)\n R, _ = cv2.Rodrigues(rvecs)\n # project 3D points onto image plane\n imgpts, _ = cv2.projectPoints(axis,\n rvecs, tvecs,\n K, d)\n\n canvas = computer_vision.draw_axis(img, corners, imgpts)\n return R, tvecs, canvas","def query_camera(self):\n ok, orig_pic = self.vs.read() # Read video stream\n if ok: # If no errors\n orig_pic = imutils.rotate(orig_pic, angle=self.camera_rot)\n curr_pic = imutils.resize(orig_pic, width=self.image_width)\n return curr_pic, orig_pic\n else:\n return None, None","def transMatrix( source=None ):\n if source is None:\n return None,None\n else:\n (x,y,z) = source[:3]\n if x == y == z == 0.0:\n return None, None \n return tmatrixaccel.transMatrix( x,y,z ),tmatrixaccel.transMatrix( -x, -y, -z )"],"string":"[\n \"def get_camera_transform(self):\\r\\n if not self.pose:\\r\\n rospy.loginfo(\\\"no pose!\\\")\\r\\n return None\\r\\n if self.pose.header.frame_id != self.role_name:\\r\\n rospy.logwarn(\\\"Unsupported frame received. Supported {}, received {}\\\".format(\\r\\n self.role_name, self.pose.header.frame_id))\\r\\n return None\\r\\n sensor_location = carla.Location(x=self.pose.pose.position.x,\\r\\n y=-self.pose.pose.position.y,\\r\\n z=self.pose.pose.position.z)\\r\\n quaternion = (\\r\\n self.pose.pose.orientation.x,\\r\\n self.pose.pose.orientation.y,\\r\\n self.pose.pose.orientation.z,\\r\\n self.pose.pose.orientation.w\\r\\n )\\r\\n roll, pitch, yaw = euler_from_quaternion(quaternion)\\r\\n # rotate to CARLA\\r\\n sensor_rotation = carla.Rotation(pitch=math.degrees(roll)-90,\\r\\n roll=math.degrees(pitch),\\r\\n yaw=-math.degrees(yaw)-90)\\r\\n return carla.Transform(sensor_location, sensor_rotation)\",\n \"def camera_matrix(self) -> TransformationMatrixType:\\n return numpy.matmul(\\n self.rotation_matrix(*self.rotation),\\n displacement_matrix(*-numpy.array(self.location)),\\n )\",\n \"def getCameraMatrix(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def get_transform_matrix(theta, phi = None, invert_rot = False, invert_focal = False):\\n\\n if phi is None:\\n phi = const.PHI_IDX * 10.0\\n\\n #extrinsic x intrinsic\\n camera_matrix = np.zeros((4, 4), dtype=np.float32)\\n\\n intrinsic_matrix = np.eye(4, dtype=np.float32)\\n extrinsic_matrix = np.eye(4, dtype=np.float32)\\n\\n sin_phi = np.sin(float(phi) / 180.0 * np.pi)\\n cos_phi = np.cos(float(phi) / 180.0 * np.pi)\\n sin_theta = np.sin(float(-theta) / 180.0 * np.pi)\\n cos_theta = np.cos(float(-theta) / 180.0 * np.pi)\\n\\n #theta rotation\\n rotation_azimuth = np.zeros((3, 3), dtype=np.float32)\\n rotation_azimuth[0, 0] = cos_theta\\n rotation_azimuth[2, 2] = cos_theta\\n rotation_azimuth[0, 2] = -sin_theta\\n rotation_azimuth[2, 0] = sin_theta\\n rotation_azimuth[1, 1] = 1.0\\n\\n #phi rotation\\n rotation_elevation = np.zeros((3, 3), dtype=np.float32)\\n rotation_elevation[0, 0] = cos_phi\\n rotation_elevation[0, 1] = sin_phi\\n rotation_elevation[1, 0] = -sin_phi\\n rotation_elevation[1, 1] = cos_phi\\n rotation_elevation[2, 2] = 1.0\\n\\n #rotate phi, then theta\\n rotation_matrix = np.matmul(rotation_azimuth, rotation_elevation)\\n if invert_rot:\\n rotation_matrix = np.linalg.inv(rotation_matrix)\\n\\n displacement = np.zeros((3, 1), dtype=np.float32)\\n displacement[0, 0] = const.DIST_TO_CAM\\n displacement = np.matmul(rotation_matrix, displacement)\\n\\n #assembling 4x4 from R + T\\n extrinsic_matrix[0:3, 0:3] = rotation_matrix\\n extrinsic_matrix[0:3, 3:4] = -displacement\\n\\n if invert_focal:\\n intrinsic_matrix[2, 2] = float(const.focal_length)\\n intrinsic_matrix[1, 1] = float(const.focal_length)\\n else:\\n intrinsic_matrix[2, 2] = 1.0 / float(const.focal_length)\\n intrinsic_matrix[1, 1] = 1.0 / float(const.focal_length)\\n\\n camera_matrix = np.matmul(extrinsic_matrix, intrinsic_matrix)\\n return camera_matrix\",\n \"def camera_transformation_from_pose(azimutal, elevation):\\n azimutal, elevation = azimutal * 2. * np.pi / 360., elevation * 2. * np.pi / 360.\\n azimutal *= -1.\\n elevation *= -1.\\n r_y = np.array([[np.cos(elevation), 0, np.sin(elevation)],\\n [0, 1, 0],\\n [-np.sin(elevation), 0, np.cos(elevation)]])\\n r_z = np.array([[np.cos(azimutal), -np.sin(azimutal), 0],\\n [np.sin(azimutal), np.cos(azimutal), 0],\\n [0, 0, 1]])\\n r = r_z.dot(r_y)\\n # world_to_camera matrix, camera_to_world matrix\\n return r, np.linalg.inv(r)\",\n \"def telescope_to_camera(telescope_coord, camera_frame):\\n x_pos = telescope_coord.cartesian.x\\n y_pos = telescope_coord.cartesian.y\\n rot = telescope_coord.rotation * -1 # reverse the rotation applied to get to this system\\n\\n if rot ==0: #if no rotation applied save a few cycles\\n x=x_pos\\n y=y_pos\\n else: # or else rotate all positions around the camera centre\\n x = x_pos*cos(rot) - y_pos*sin(rot)\\n y = y_pos*sin(rot) + y_pos*cos(rot)\\n\\n f = telescope_coord.focal_length\\n x = x*(f/u.m) # Remove distance units here as we are using small angle approx\\n y = y*(f/u.m)\\n\\n representation = CartesianRepresentation(x.value*u.m ,y.value*u.m,0*u.m)\\n\\n return camera_frame.realize_frame(representation)\",\n \"def get_frame(cap):\\n\\n #camera matrix for camera calibration\\n mtx = np.array(np.mat(\\\"588.4525598886621, 0, 301.8008794717551; 0, 588.9763096391521, 242.617026416902; 0, 0, 1\\\"))\\n\\n #distrotion coefficients for camera calibration\\n dist = np.array(np.mat(\\\"-0.4351555722591889, 0.2082765081608728, -0.006072767012672472, 0.008139871640987759, 0\\\"))\\n\\n #get image frame from the camera\\n ret, frame = cap.read()\\n\\n return frame\\n\\n h, w = frame.shape[:2]\\n\\n #get the new optimal camera matrix and the roi which can be used to crop the result\\n newcameramtx, roi=cv2.getOptimalNewCameraMatrix(mtx,dist,(w,h),0,(w,h))\\n\\n #get the undistroted image\\n dst = cv2.undistort(frame, mtx, dist, None, newcameramtx)\\n\\n x,y,w,h = roi\\n\\n #get the cropped image\\n dst = dst[y:y+h, x:x+w]\\n h, w = dst.shape[:2]\\n\\n #furthur crop the image to reduce the size of arena\\n dst = dst[int(h/7):int(h*6/7), int(w/7):int(w*6/7)]\\n\\n #resize the arena to ARENA_SIZE\\n dst = cv2.resize(dst, ARENA_SIZE, interpolation= cv2.INTER_CUBIC)\\n\\n return dst\",\n \"def camera_to_world(self, X):\\n raise NotImplementedError\",\n \"def world_to_camera(self, X):\\n raise NotImplementedError\",\n \"def ExtractCameraPose(E):\\n u, s, v = np.linalg.svd(E, full_matrices=True)\\n w = np.array([[0, -1, 0],\\n [1, 0, 0],\\n [0, 0, 1]]).reshape(3, 3)\\n c1 = u[:, 2].reshape(3, 1)\\n r1 = np.dot(np.dot(u, w), v).reshape(3, 3)\\n c2 = -u[:, 2].reshape(3, 1)\\n r2 = np.dot(np.dot(u, w), v).reshape(3, 3)\\n c3 = u[:, 2].reshape(3, 1)\\n r3 = np.dot(np.dot(u, w.T), v).reshape(3, 3)\\n c4 = -u[:, 2].reshape(3, 1)\\n r4 = np.dot(np.dot(u, w.T), v).reshape(3, 3)\\n if np.linalg.det(r1) < 0:\\n c1 = -c1\\n r1 = -r1\\n if np.linalg.det(r2) < 0:\\n c2 = -c2\\n r2 = -r2\\n if np.linalg.det(r3) < 0:\\n c3 = -c3\\n r3 = -r3\\n if np.linalg.det(r4) < 0:\\n c4 = -c4\\n r4 = -r4\\n cam_center = np.array([c1, c2, c3, c4])\\n cam_rotation = np.array([r1, r2, r3, r4])\\n return cam_center, cam_rotation\",\n \"def map_to_matrix(x, y):\\n x_pos = round(x * ((MATRIX_SIZE_X - 1)/(FRAME_W - 1)))\\n y_pos = round(y * ((MATRIX_SIZE_Y - 1)/(FRAME_H - 1)))\\n\\n x_pos = (MATRIX_SIZE_X - 1) - x_pos #invert x direction (left and right) to account for camera perspective\\n\\n return x_pos, y_pos\",\n \"def getMatrix(self, frame):\\n radian=np.radians(self.getValue(frame))\\n c=np.cos(radian)\\n s=np.sin(radian)\\n self.matrix[2, 2]=c\\n self.matrix[2, 0]=s\\n self.matrix[0, 2]=-s\\n self.matrix[0, 0]=c\\n return self.matrix\",\n \"def cameraToWorld(self, p):\\n result = self.camPos\\n result += p[2] * self.camZ # result is now in the middle of the view-plane\\n result += p[0] * self.camX # result is now in the middle-left of the view-plane\\n result += p[1] * self.camY # result is now the world-space equivalent of p\\n return result\",\n \"def modelview_matrix(self):\\n camera = self.figure.scene.camera\\n return camera.view_transform_matrix.to_array().astype(np.float32)\",\n \"def camera_to_telescope(camera_coord, telescope_frame):\\n x_pos = camera_coord.cartesian.x\\n y_pos = camera_coord.cartesian.y\\n\\n rot = telescope_frame.rotation\\n if rot ==0:\\n x=x_pos\\n y=y_pos\\n else:\\n x = x_pos*cos(rot) - y_pos*sin(rot)\\n y = y_pos*sin(rot) + y_pos*cos(rot)\\n\\n f = telescope_frame.focal_length\\n\\n x = (x/f) * u.deg\\n y = (y/f) * u.deg\\n representation = CartesianRepresentation(x,y,0*u.deg)\\n\\n return telescope_frame.realize_frame(representation)\",\n \"def camera_to_object_transform(self):\\n # form the full object to camera transform\\n T_stp_camera = self.stp_to_camera_transform()\\n T_obj_stp = self.object_to_stp_transform()\\n T_obj_camera = T_stp_camera.dot(T_obj_stp)\\n return T_obj_camera\",\n \"def create_cam2world_matrix(forward_vector,\\n origin,\\n device=None):\\n \\\"\\\"\\\"\\\"\\\"\\\"\\n\\n forward_vector = normalize_vecs(forward_vector)\\n up_vector = torch.tensor([0, 1, 0], dtype=torch.float, device=device) \\\\\\n .expand_as(forward_vector)\\n\\n left_vector = normalize_vecs(\\n torch.cross(up_vector,\\n forward_vector,\\n dim=-1))\\n\\n up_vector = normalize_vecs(\\n torch.cross(forward_vector,\\n left_vector,\\n dim=-1))\\n\\n rotation_matrix = torch.eye(4, device=device) \\\\\\n .unsqueeze(0) \\\\\\n .repeat(forward_vector.shape[0], 1, 1)\\n rotation_matrix[:, :3, :3] = torch.stack(\\n (-left_vector, up_vector, -forward_vector), axis=-1)\\n\\n translation_matrix = torch.eye(4, device=device) \\\\\\n .unsqueeze(0) \\\\\\n .repeat(forward_vector.shape[0], 1, 1)\\n translation_matrix[:, :3, 3] = origin\\n\\n cam2world = translation_matrix @ rotation_matrix\\n\\n return cam2world\",\n \"def transform_camera_pose_to_world_pose(self):\\n for pose in self.close_positions_camera:\\n self.close_positions_world.append(self.get_world_pose_for_camera_pose(pose))\\n\\n for pose in self.medium_positions_camera:\\n self.medium_positions_world.append(self.get_world_pose_for_camera_pose(pose))\\n\\n for pose in self.far_positions_camera:\\n self.far_positions_world.append(self.get_world_pose_for_camera_pose(pose))\",\n \"def computeMVP(self):\\n projMat = self.converterYUR\\n modelViewMat = self.transforMat.invertCompose(\\n Globals.render.getTransform(self.cameraNode)).getMat()\\n return UnalignedLMatrix4f(modelViewMat * projMat)\",\n \"def get_transformation_matrix(self, fromFrame, toFrame):\\n fromIndex = self.frameNames.index(fromFrame)\\n toIndex = self.frameNames.index(toFrame)\\n #return get_transformation_matrix(self.frameStack, fromIndex, toIndex)\\n return self._get_transformation_matrix_with_indices(fromIndex, toIndex)\",\n \"def getMatrix(self, frame):\\n radian=np.radians(self.getValue(frame))\\n c=np.cos(radian)\\n s=np.sin(radian)\\n self.matrix[1, 1]=c\\n self.matrix[1, 2]=s\\n self.matrix[2, 1]=-s\\n self.matrix[2, 2]=c\\n return self.matrix\",\n \"def transformation_matrix(self) -> TransformationMatrixType:\\n # camera translation\\n if self._transformation_matrix is None:\\n self._transformation_matrix = numpy.matmul(\\n self.projection_matrix,\\n self.camera_matrix,\\n )\\n\\n return self._transformation_matrix\",\n \"def proj_to_velo(calib_data):\\n rect = calib_data[\\\"R0_rect\\\"].reshape(3, 3)\\n #to transform a point from Lidar framce to camera frame\\n #reshape the flat line with 12 elements to 3X4 matrix\\n velo_to_cam = calib_data[\\\"Tr_velo_to_cam\\\"].reshape(3, 4)\\n#print('velo2cam', velo_to_cam)\\n inv_rect = np.linalg.inv(rect)\\n #select all rows and only first three columns\\n#print('velo_to_cam[:, :3]', velo_to_cam[:, :3])\\n #select all rows and only first three columns\\n inv_velo_to_cam = np.linalg.pinv(velo_to_cam[:, :3])\\n return np.dot(inv_velo_to_cam, inv_rect)\",\n \"def getMatrix(self, frame):\\n radian=np.radians(self.getValue(frame))\\n c=np.cos(radian)\\n s=np.sin(radian)\\n self.matrix[0, 0]=c\\n self.matrix[0, 1]=s\\n self.matrix[1, 0]=-s\\n self.matrix[1, 1]=c\\n return self.matrix\",\n \"def read_camera(self):\\n _, frame = self.camera.read()\\n return self.mirror(frame)\",\n \"def stp_to_camera_transform(self):\\n # setup variables\\n camera_xyz_w = self.cam_pos\\n camera_rot_w = self.cam_rot\\n camera_int_pt_w = self.cam_interest_pt\\n camera_xyz_obj_p = camera_xyz_w - camera_int_pt_w\\n \\n # get the distance from the camera to the world\\n camera_dist_xy = np.linalg.norm(camera_xyz_w[:2])\\n z = [0,0,np.linalg.norm(camera_xyz_w[:3])]\\n\\n # form the rotations about the x and z axis for the object on the tabletop\\n theta = camera_rot_w[0] * np.pi / 180.0\\n phi = -camera_rot_w[2] * np.pi / 180.0 + np.pi / 2.0\\n camera_rot_obj_p_z = np.array([[np.cos(phi), -np.sin(phi), 0],\\n [np.sin(phi), np.cos(phi), 0],\\n [0, 0, 1]])\\n\\n camera_rot_obj_p_x = np.array([[1, 0, 0],\\n [0, np.cos(theta), -np.sin(theta)],\\n [0, np.sin(theta), np.cos(theta)]])\\n \\n # form the full rotation matrix, swapping axes to match maya\\n camera_md = np.array([[0, 1, 0],\\n [1, 0, 0],\\n [0, 0, -1]])\\n camera_rot_obj_p = camera_md.dot(camera_rot_obj_p_z.dot(camera_rot_obj_p_x))\\n camera_rot_obj_p = camera_rot_obj_p.T\\n \\n # form the full object to camera transform\\n R_stp_camera = camera_rot_obj_p\\n t_stp_camera = np.array(z)\\n return RigidTransform(rotation=R_stp_camera,\\n translation=t_stp_camera,\\n from_frame='stp', to_frame='camera')\",\n \"def testCalculateTransform(self):\\n # Create some points in the first frame.\\n z = 4.0\\n self.evaluator.camera_height = z\\n first_points = numpy.array(\\n [[0, 0, z], [2, 0, z], [2, 5, z], [0, 5, z]], dtype=numpy.float32)\\n # Create a transformation that will move the camera\\n R = numpy.array([[0.0, -1.0, 0.0], [1.0, 0.0, 0.0], [0.0, 0.0, 1.0]])\\n t = numpy.array([[3.0], [-5.0], [0.0]])\\n expected_result = numpy.eye(4)\\n expected_result[0:3, 0:3] = R\\n expected_result[0:3, 3:] = t\\n # Determine where the second points would be given that.\\n second_points = (numpy.matmul(\\n R, first_points.transpose()) + t).transpose()\\n # Create a simple intrinsic matrix to project onto a fictional camera\\n intrinsic = numpy.array(\\n [[1.0, 0.0, 20.0], [0.0, 1.0, 20.0], [0.0, 0.0, 1.0]])\\n # Use no distortion or transformations\\n rvec = numpy.zeros((3, 1))\\n tvec = rvec\\n distortion = numpy.zeros((5, 1))\\n # Project the points into the camera\\n (camera_first_points, _) = cv2.projectPoints(\\n first_points, rvec, tvec, intrinsic, distortion)\\n camera_first_points = camera_first_points.squeeze()\\n (camera_second_points, _) = cv2.projectPoints(\\n second_points, rvec, tvec, intrinsic, distortion)\\n camera_second_points = camera_second_points.squeeze()\\n # Using these projected points, can the object recover the correct initial transform\\n result = self.evaluator._calculateTransform(\\n camera_first_points, camera_second_points, intrinsic)\\n # The matrix comparisions aren't reliable near zero, so check elements manually.\\n for i in range(expected_result.shape[0]):\\n for j in range(expected_result.shape[1]):\\n result_element = result[i, j]\\n expected_element = expected_result[i, j]\\n self.assertAlmostEqual(result_element, expected_element, 6,\\n 'Matrix element ({0:d}, {1:d}) is incorrect.'.format(i, j))\",\n \"def get_computed_camera_poses(self):\\n pairs = sorted((timestamp, pose) for timestamp, pose in self.frame_deltas.items())\\n current_pose = tf.Transform()\\n computed_poses = {}\\n for timestamp, delta in pairs:\\n delta = delta.find_relative(tf.Transform()) # Flip the direction from previous pose relative to new\\n current_pose = current_pose.find_independent(delta)\\n computed_poses[timestamp] = current_pose\\n return computed_poses\",\n \"def CoordTrans(frame1, frame2, original_vec, oe=np.zeros(6), \\n theta_gst=float('NaN'), lla_gs=np.zeros(3), mu=c.mu_earth, \\n r_body=c.r_earth):\\n\\n # Orbital Elements\\n a, e, inc, raan, w, nu = oe\\n\\n # Warnings\\n oe_frames = ['ric', 'ntw', 'pqw']\\n if any(frame in oe_frames for frame in (frame1, frame2)):\\n if oe.dot(oe) == 0:\\n print('ERROR: You forgot to define the orbital elements!')\\n\\n topocentric_frames = ['sez']\\n if any(frame in topocentric_frames for frame in (frame1, frame2)):\\n if lla_gs.dot(lla_gs) == 0:\\n print('ERROR: You forgot lla for the ground stations!')\\n\\n # Coordinate System Logic\\n if frame1.lower() == 'bci':\\n if frame2.lower() == 'bcbf':\\n rotated_vec = bci2bcbf(original_vec, theta_gst)\\n if np.isnan(theta_gst):\\n print('ERROR: You forgot to define theta_gst!')\\n \\n elif frame2.lower() == 'ric':\\n rotated_vec = bci2ric(original_vec, raan, inc, w, nu)\\n \\n elif frame2.lower() == 'ntw':\\n rotated_vec = bci2ntw(original_vec, e, raan, inc, w, nu)\\n \\n elif frame2.lower() == 'pqw':\\n rotated_vec = bci2pqw(original_vec, raan, inc, w)\\n \\n elif frame2.lower() == 'lla':\\n rotated_vec1 = bci2bcbf(original_vec, theta_gst)\\n rotated_vec = bcbf2lla(rotated_vec1, r_body=r_body)\\n if np.isnan(theta_gst):\\n print('ERROR: You forgot to define theta_gst!')\\n \\n elif frame2.lower() == 'sez':\\n rotated_vec1 = bci2bcbf(original_vec, theta_gst)\\n rotated_vec = bcbf2sez(rotated_vec1, lla_gs, r_body=r_body)\\n if np.isnan(theta_gst):\\n print('ERROR: You forgot to define theta_gst!')\\n\\n else:\\n print('ERROR: Frame2 is not included in this function!')\\n\\n elif frame1.lower() == 'bcbf':\\n if frame2.lower() == 'bci':\\n rotated_vec = bcbf2bci(original_vec, theta_gst)\\n if np.isnan(theta_gst):\\n print('ERROR: You forgot to define theta_gst!')\\n \\n elif frame2.lower() == 'ric':\\n rotated_vec1 = bcbf2bci(original_vec, theta_gst)\\n rotated_vec = bci2ric(rotated_vec1, raan, inc, w, nu)\\n if np.isnan(theta_gst):\\n print('ERROR: You forgot to define theta_gst!')\\n \\n elif frame2.lower() == 'ntw':\\n rotated_vec1 = bcbf2bci(original_vec, theta_gst)\\n rotated_vec = bci2ntw(rotated_vec1, e, raan, inc, w, nu)\\n if np.isnan(theta_gst):\\n print('ERROR: You forgot to define theta_gst!')\\n \\n elif frame2.lower() == 'pqw':\\n rotated_vec1 = bcbf2bci(original_vec, theta_gst)\\n rotated_vec = bci2pqw(rotated_vec1, raan, inc, w)\\n if np.isnan(theta_gst):\\n print('ERROR: You forgot to define theta_gst!')\\n \\n elif frame2.lower() == 'lla':\\n rotated_vec = bcbf2lla(original_vec, r_body=r_body)\\n \\n elif frame2.lower() == 'sez':\\n rotated_vec = bcbf2sez(original_vec, lla_gs, r_body=r_body)\\n\\n else:\\n print('ERROR: Frame2 is not included in this function!')\\n\\n elif frame1.lower() == 'ric':\\n rotated_vec1 = ric2bci(original_vec, raan, inc, w, nu)\\n if frame2.lower() == 'bcbf':\\n rotated_vec = bci2bcbf(rotated_vec1, theta_gst)\\n if np.isnan(theta_gst):\\n print('ERROR: You forgot to define theta_gst!')\\n \\n elif frame2.lower() == 'bci':\\n rotated_vec = rotated_vec1\\n \\n elif frame2.lower() == 'ntw':\\n rotated_vec = bci2ntw(rotated_vec1, e, raan, inc, w, nu)\\n \\n elif frame2.lower() == 'pqw':\\n rotated_vec = bci2pqw(rotated_vec1, raan, inc, w)\\n \\n elif frame2.lower() == 'lla':\\n rotated_vec2 = bci2bcbf(rotated_vec1, theta_gst)\\n rotated_vec = bcbf2lla(rotated_vec2, r_body=r_body)\\n if np.isnan(theta_gst):\\n print('ERROR: You forgot to define theta_gst!')\\n \\n elif frame2.lower() == 'sez':\\n rotated_vec2 = bci2bcbf(rotated_vec1, theta_gst)\\n rotated_vec = bcbf2sez(rotated_vec2, lla_gs, r_body=r_body)\\n if np.isnan(theta_gst):\\n print('ERROR: You forgot to define theta_gst!')\\n\\n else:\\n print('ERROR: Frame2 is not included in this function!')\\n\\n elif frame1.lower() == 'ntw':\\n rotated_vec1 = ntw2bci(original_vec, e, raan, inc, w, nu)\\n if frame2.lower() == 'bcbf':\\n rotated_vec = bci2bcbf(rotated_vec1, theta_gst)\\n if np.isnan(theta_gst):\\n print('ERROR: You forgot to define theta_gst!')\\n \\n elif frame2.lower() == 'ric':\\n rotated_vec = bci2ric(rotated_vec1, raan, inc, w, nu)\\n \\n elif frame2.lower() == 'bci':\\n rotated_vec = rotated_vec1\\n \\n elif frame2.lower() == 'pqw':\\n rotated_vec = bci2pqw(rotated_vec1, raan, inc, w)\\n \\n elif frame2.lower() == 'lla':\\n rotated_vec2 = bci2bcbf(rotated_vec1, theta_gst)\\n rotated_vec = bcbf2lla(rotated_vec2, r_body=r_body)\\n if np.isnan(theta_gst):\\n print('ERROR: You forgot to define theta_gst!')\\n \\n elif frame2.lower() == 'sez':\\n rotated_vec2 = bci2bcbf(rotated_vec1, theta_gst)\\n rotated_vec = bcbf2sez(rotated_vec2, lla_gs, r_body=r_body)\\n if np.isnan(theta_gst):\\n print('ERROR: You forgot to define theta_gst!')\\n\\n else:\\n print('ERROR: Frame2 is not included in this function!')\\n\\n elif frame1.lower() == 'pqw':\\n rotated_vec1 = pqw2bci(original_vec, raan, inc, w)\\n if frame2.lower() == 'bcbf':\\n rotated_vec = bci2bcbf(rotated_vec1, theta_gst)\\n if np.isnan(theta_gst):\\n print('ERROR: You forgot to define theta_gst!')\\n \\n elif frame2.lower() == 'ric':\\n rotated_vec = bci2ric(rotated_vec1, raan, inc, w, nu)\\n \\n elif frame2.lower() == 'ntw':\\n rotated_vec = bci2ntw(rotated_vec1, e, raan, inc, w, nu)\\n \\n elif frame2.lower() == 'bci':\\n rotated_vec = rotated_vec1\\n \\n elif frame2.lower() == 'lla':\\n rotated_vec2 = bci2bcbf(rotated_vec1, theta_gst)\\n rotated_vec = bcbf2lla(rotated_vec2, r_body=r_body)\\n if np.isnan(theta_gst):\\n print('ERROR: You forgot to define theta_gst!')\\n \\n elif frame2.lower() == 'sez':\\n rotated_vec2 = bci2bcbf(rotated_vec1, theta_gst)\\n rotated_vec = bcbf2sez(rotated_vec2, lla_gs, r_body=r_body)\\n if np.isnan(theta_gst):\\n print('ERROR: You forgot to define theta_gst!')\\n\\n else:\\n print('ERROR: Frame2 is not included in this function!')\\n\\n elif frame1.lower() == 'lla':\\n rotated_vec1 = lla2bcbf(original_vec, r_body=r_body)\\n if frame2.lower() == 'bcbf':\\n rotated_vec = rotated_vec1\\n \\n elif frame2.lower() == 'ric':\\n rotated_vec2 = bcbf2bci(rotated_vec1, theta_gst)\\n rotated_vec = bci2ric(rotated_vec2, raan, inc, w, nu)\\n if np.isnan(theta_gst):\\n print('ERROR: You forgot to define theta_gst!')\\n \\n elif frame2.lower() == 'ntw':\\n rotated_vec2 = bcbf2bci(rotated_vec1, theta_gst)\\n rotated_vec = bci2ntw(rotated_vec2, e, raan, inc, w, nu)\\n if np.isnan(theta_gst):\\n print('ERROR: You forgot to define theta_gst!')\\n \\n elif frame2.lower() == 'pqw':\\n rotated_vec2 = bcbf2bci(rotated_vec1, theta_gst)\\n rotated_vec = bci2pqw(rotated_vec2, raan, inc, w)\\n if np.isnan(theta_gst):\\n print('ERROR: You forgot to define theta_gst!')\\n \\n elif frame2.lower() == 'bci':\\n rotated_vec = bcbf2bci(rotated_vec1, theta_gst)\\n if np.isnan(theta_gst):\\n print('ERROR: You forgot to define theta_gst!')\\n \\n elif frame2.lower() == 'sez':\\n rotated_vec = bcbf2sez(rotated_vec1, lla_gs, r_body=r_body)\\n\\n else:\\n print('ERROR: Frame2 is not included in this function!')\\n\\n elif frame1.lower() == 'sez':\\n rotated_vec1 = sez2bcbf(original_vec, lla_gs, r_body=r_body)\\n rotated_vec2 = bcbf2bci(rotated_vec1, theta_gst)\\n if np.isnan(theta_gst):\\n print('ERROR: You forgot to define theta_gst!')\\n \\n if frame2.lower() == 'bcbf':\\n rotated_vec = rotated_vec1\\n \\n elif frame2.lower() == 'ric':\\n rotated_vec = bci2ric(rotated_vec2, raan, inc, w, nu)\\n \\n elif frame2.lower() == 'ntw':\\n rotated_vec = bci2ntw(rotated_vec2, e, raan, inc, w, nu)\\n \\n elif frame2.lower() == 'pqw':\\n rotated_vec = bci2pqw(rotated_vec2, raan, inc, w)\\n \\n elif frame2.lower() == 'lla':\\n rotated_vec = bcbf2lla(rotated_vec1, r_body=r_body)\\n \\n elif frame2.lower() == 'bci':\\n rotated_vec = rotated_vec2\\n\\n else:\\n print('ERROR: Frame2 is not included in this function!')\\n\\n else:\\n print('ERROR: Frame1 is not included in this function!')\\n\\n return rotated_vec\",\n \"def compute_right_camera_pose(left_camera_to_world, left_to_right):\\n left_world_to_camera = np.linalg.inv(left_camera_to_world)\\n right_world_to_camera = np.matmul(left_to_right, left_world_to_camera)\\n right_camera_to_world = np.linalg.inv(right_world_to_camera)\\n return right_camera_to_world\",\n \"def getMatrix(self, frame):\\n self.matrix[3, 0]=self.getValue(frame)\\n return self.matrix\",\n \"def filter_rotation(frame):\\n return frame[frame['direction'] != 'none'].copy()\",\n \"def computeWorldTransformationFromFoot(self):\\n self.corba.signal(self.perceivedBody).recompute(\\n self.corba.signal(self.perceivedBody).time + 1)\\n self.robot.dynamic.signal(\\n self.trackedBody).recompute(self.robot.dynamic.signal(\\n self.trackedBody).time + 1)\\n\\n mocapMfoot = XYThetaToHomogeneousMatrix(\\n self.corba.signal(self.perceivedBody).value)\\n sotMfoot = np.matrix(self.robot.dynamic.signal(\\n self.trackedBody).value)\\n\\n # mocap position w.r.t sot frame\\n sotMmocap = sotMfoot * np.linalg.inv(mocapMfoot)\\n return matrixToTuple(sotMmocap)\",\n \"def relative_pose_cam_to_body(\\n relative_scene_pose, Rt_cam2_gt\\n ):\\n relative_scene_pose = (\\n np.linalg.inv(Rt_cam2_gt)\\n @ relative_scene_pose\\n @ Rt_cam2_gt\\n )\\n return relative_scene_pose\",\n \"def get_world_pose_for_camera_pose(self, pose):\\n\\n # Create a point stamped from the given position\\n camera_point = geometry_msgs.msg.PointStamped()\\n camera_point.header.stamp = rospy.Time.now()\\n camera_point.header.frame_id = 'camera'\\n camera_point.point.x = pose[0]\\n camera_point.point.y = pose[1]\\n camera_point.point.z = pose[2]\\n\\n # Wait for the transformation to be available\\n time = rospy.Time().now()\\n self.listener.waitForTransform('camera', 'world', time, rospy.Duration(5))\\n world_point = self.listener.transformPoint('world', camera_point)\\n\\n # Return the new coordinates\\n return [world_point.point.x, world_point.point.y, world_point.point.z]\",\n \"def cam_to_world(cam_point, world_to_cam):\\n # cam_point = np.array([cam_pose[0], cam_pose[1], cam_pose[2]])\\n\\n obj_vector = np.concatenate((cam_point, np.ones(1))).reshape((4, 1))\\n world_point = np.dot(world_to_cam, obj_vector)\\n\\n world_point = [p[0] for p in world_point]\\n return world_point[0:3]\",\n \"def get_world_trans(m_obj):\\n plug = get_world_matrix_plug(m_obj, 0)\\n matrix_obj = plug.asMObject()\\n matrix_data = oMa.MFnMatrixData(matrix_obj)\\n matrix = matrix_data.matrix()\\n\\n trans_matrix = oMa.MTransformationMatrix(matrix)\\n trans = trans_matrix.translation(oMa.MSpace.kWorld)\\n\\n return trans\",\n \"def camera_matrix(e, p, t):\\n # Translates all points such that the camera is centered at the origin.\\n T = np.array([[1, 0, 0, -e[0]],\\n [0, 1, 0, -e[1]],\\n [0, 0, 1, -e[2]],\\n [0, 0, 0, 1]])\\n\\n # Set up orthonormal basis.\\n w = e - p\\n w = w / np.linalg.norm(w)\\n u = np.cross(t, w)\\n u = u / np.linalg.norm(u)\\n v = np.cross(w, u)\\n\\n # Rotate points such that camera is aligned with UVW-axes (g -> -z-axis).\\n R = np.array([[u[0], u[1], u[2], 0],\\n [v[0], v[1], v[2], 0],\\n [w[0], w[1], w[2], 0],\\n [ 0, 0, 0, 1]])\\n return R.dot(T)\",\n \"def get_render_obs(self):\\n x, y, z = self.robot.body_xyz\\n # print (x, y, z)\\n cameraEyePosition = list([x, y-0.75, 1.0])\\n cameraTargetPosition = [x, y, 1.0]\\n cameraUpVector = [0, 0, 1]\\n\\n fov = 120\\n aspect = self.render_dims[0] / self.render_dims[1]\\n nearPlane = 0.05 # this ensures outside body, may see limbs\\n farPlane = 100.0\\n\\n # TODO: fix me to be along moving axis\\n viewMatrix = p.computeViewMatrix(cameraEyePosition, cameraTargetPosition, cameraUpVector, physicsClientId=self.physicsClientId)\\n # viewMatrix = p.computeViewMatrixFromYawPitchRoll(camTargetPos, camDistance, yaw, pitch, roll, upAxisIndex)\\n projectionMatrix = p.computeProjectionMatrixFOV(fov, aspect, nearPlane, farPlane);\\n img_arr = p.getCameraImage(self.render_dims[0], self.render_dims[1], viewMatrix, projectionMatrix, renderer=p.ER_BULLET_HARDWARE_OPENGL, physicsClientId=self.physicsClientId)\\n\\n # w=img_arr[0] #width of the image, in pixels\\n # h=img_arr[1] #height of the image, in pixels\\n rgb=img_arr[2] #color data RGB\\n gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)\\n gray = gray.reshape((1, *self.render_dims))\\n gray[gray > 0] = 255\\n return gray\",\n \"def getMatrix(self, frame):\\n self.matrix[3, 2]=self.getValue(frame)\\n return self.matrix\",\n \"def getMatrix(self, frame):\\n self.matrix[3, 1]=self.getValue(frame)\\n return self.matrix\",\n \"def camera_2_world(self, o, d):\\r\\n wo = self.camera2world_point @ ti.Vector([o.x, o.y, o.z, 1.0])\\r\\n wd = self.camera2world_vec @ d\\r\\n return ti.Vector([wo.x,wo.y,wo.z]), wd\",\n \"def screenToCamera(self,x,y):\\n #self.x = x\\n #self.y = y\\n new_x = x / (self.surf.get_width() - 1) - 0.5\\n #-(new_x)\\n new_y = y / (self.surf.get_height() - 1)\\n new_y = (1.0 - cy) - 0.5\\n new_z = -self.camNear\\n formula = math3dsol.VectorN((new_x,new_y,new_z))\\n return formula\\n\\n # FINISH ME!!!\",\n \"def intrinsic_matrix_from_camera(w, h, fov):\\n (cx, cy), f = calc_focal_values(w, h, fov)\\n return np.array([[f, 0, cx], [0, f, cy], [0, 0, 1]])\",\n \"def set_modelview_from_camera(Rt):\\n \\n glMatrixMode(GL_MODELVIEW)\\n glLoadIdentity()\\n \\n # rotate teapot 90 deg around x-axis so that z-axis is up\\n Rx = np.array([[1,0,0],[0,0,-1],[0,1,0]])\\n \\n # set rotation to best approximation\\n R = Rt[:,:3]\\n U,S,V = np.linalg.svd(R)\\n R = np.dot(U,V)\\n R[0,:] = -R[0,:] # change sign of x-axis\\n \\n # set translation\\n t = Rt[:,3]\\n \\n # setup 4*4 model view matrix\\n M = np.eye(4)\\n M[:3,:3] = np.dot(R,Rx)\\n M[:3,3] = t\\n\\n # transpose and flatten to get column order\\n M = M.T\\n \\n m = M.flatten()\\n \\n # replace model view with the new matrix\\n glLoadMatrixf(m)\",\n \"def get_2d_poses(self, frame: int, camera: int) -> np.ndarray:\\n poses = self._get_2d_data_by_type(frame, camera, 'poses')\\n if frame in poses:\\n return np.asarray(poses[frame])\\n else:\\n return np.array([])\",\n \"def camera_coords_to_world_coords(point, cam_height, cam_angle):\\n\\n # adjust the axis order\\n point = np.array([point[2], point[0], point[1]])\\n\\n # calculate the vectors of the camera axis in the desired coordinate system\\n cam_direction = np.array([np.cos(cam_angle), 0, -np.sin(cam_angle)])\\n z = cam_direction\\n x = np.cross(np.array([0, 0, 1]), cam_direction)\\n y = np.cross(z, x)\\n\\n # transposed rotation matrix\\n rotation = np.vstack([x, y, z])\\n\\n # translation vector\\n translation = np.array([0, 0, cam_height])\\n\\n return rotation @ (point - translation)\",\n \"def get_render_obs(self):\\n x, y, z = self.robot.body_xyz\\n # print (x, y, z)\\n\\n if self.camera_type == 'follow':\\n cameraEyePosition = [x, y-1.25, 1.0]\\n cameraTargetPosition = [x, y, 1.0]\\n elif self.camera_type == 'fixed':\\n cameraEyePosition = [2.0, y-2.5, 1.0]\\n cameraTargetPosition = [2.0, y, 1.0]\\n\\n cameraUpVector = [0, 0, 1]\\n\\n fov = 90\\n aspect = self.render_dims[0] / self.render_dims[1]\\n nearPlane = 0.05 # this ensures outside body, may see limbs\\n farPlane = 100.0\\n\\n viewMatrix = p.computeViewMatrix(cameraEyePosition, cameraTargetPosition, cameraUpVector, physicsClientId=self.physicsClientId)\\n projectionMatrix = p.computeProjectionMatrixFOV(fov, aspect, nearPlane, farPlane);\\n img_arr = p.getCameraImage(self.render_dims[0], self.render_dims[1], viewMatrix, projectionMatrix, renderer=p.ER_BULLET_HARDWARE_OPENGL, physicsClientId=self.physicsClientId)\\n\\n rgb=img_arr[2] #color data RGB\\n gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)\\n gray = gray.reshape((1, *self.render_dims))\\n gray[gray > 0] = 255\\n\\n # assign patch at bottom to show distance, this is to differentiate frames\\n # bar_width_pix = int(y/5.0*self.render_dims[1])\\n # bar_height_pix = 10\\n # gray[0][self.render_dims[0]-bar_height_pix:, 0:bar_width_pix] = 255\\n return gray\",\n \"def get_camera(self, video: int, frame: int) -> Union[Camera, None]:\\n params = self._get_calibration_params(video, frame)\\n # Check if we found the camera parameters\\n if not (params[0]):\\n print(params[1])\\n return\\n else:\\n params = params[1]\\n \\n # Construct the Camera object\\n camera = Camera(params['K'], params['rvec'], params['tvec'], params['distCoef'], params['w'], params['h'])\\n\\n # Return the camera\\n return camera\",\n \"def get_projection_mapping(self, cam_pos, cam_rot, local_frame=False, range1=True):\\n\\n cam_pos = cam_pos.copy()\\n cam_pos[2] += self.h_offset\\n\\n K = self.make_camera_matrix()\\n R_opt = self.make_optical_rotation_matrix()\\n T_opt = affines.compose([0, 0, 0], R_opt, [1.0, 1.0, 1.0])\\n T_opt_inv = np.linalg.inv(T_opt)\\n T = self.make_world_to_camera_mat(cam_pos, cam_rot)\\n Tinv = np.linalg.inv(T)\\n\\n # Get the map position encodings (MxMx3)\\n pts_w = self.get_world_coord_grid()[..., np.newaxis]\\n\\n # Get the coordinates in camera frame:\\n if not local_frame:\\n # If we're using a global map frame, transform the map coordinates into the camera frame\\n pts_cam = np.matmul(Tinv[np.newaxis, ...], pts_w)\\n else:\\n # If we're using local frame, camera is centered in the map, but pitch must still be taken into account!\\n # TODO: Fix this and add pitch\\n pts_cam = pts_w\\n pts_cam[:, 0:2] = pts_cam[:, 0:2] - self.map_world_size_px / 2\\n\\n # Get the coordinates in optical frame\\n pts_opt = np.matmul(T_opt_inv[np.newaxis, ...], pts_cam)\\n\\n # Get the 3D coordinates of the map pixels in the image frame:\\n pts_img = np.matmul(K[np.newaxis, ...], pts_opt[:, 0:3, :])\\n\\n # Convert to homogeneous (image-plane) coordinates\\n valid_z = pts_img[:, 2:3, :] > 0\\n\\n pts_img = pts_img / (pts_img[:, 2:3] + 1e-9)\\n #pts_img[:, 0] = pts_img[:, 0] / (pts_img[:, 2] + 1e-9)\\n #pts_img[:, 1] = pts_img[:, 1] / (pts_img[:, 2] + 1e-9)\\n\\n # Mask out all the map elements that don't project on the image\\n valid_y1 = pts_img[:, 0:1, :] > 0\\n valid_y2 = pts_img[:, 0:1, :] < self.res_x\\n valid_x1 = pts_img[:, 1:2, :] > 0\\n valid_x2 = pts_img[:, 1:2, :] < self.res_y\\n\\n # Throw away the homogeneous Z coordinate\\n pts_img = pts_img[:, 0:2]\\n\\n valid = valid_y1 * valid_y2 * valid_x1 * valid_x2 * valid_z\\n\\n # PyTorch takes projection mappings in -1 to 1 range:\\n if range1:\\n pts_img[:, 0] = (-pts_img[:, 0] + self.res_x / 2) / (self.res_x / 2)\\n pts_img[:, 1] = (-pts_img[:, 1] + self.res_y / 2) / (self.res_y / 2)\\n\\n # Make sure the invalid points are out of range\\n pts_img = pts_img * valid + 2 * np.ones_like(pts_img) * (1 - valid)\\n else:\\n pts_img = pts_img * valid\\n\\n # Remove the extra 1-length dimension\\n pts_img = pts_img.squeeze()\\n\\n # Reshape into the 2D map representation\\n pts_img = np.reshape(pts_img, [self.map_size_px, self.map_size_px, 2])\\n\\n return pts_img\",\n \"def closest_approach_to_camera(scene, speaker_object) -> (float, int):\\n max_dist = sys.float_info.max\\n at_time = scene.frame_start\\n for frame in range(scene.frame_start, scene.frame_end + 1):\\n scene.frame_set(frame)\\n rel = speaker_object.matrix_world.to_translation() - scene.camera.matrix_world.to_translation()\\n dist = norm(rel)\\n\\n if dist < max_dist:\\n max_dist = dist\\n at_time = frame\\n\\n return max_dist, at_time\",\n \"def adjust_camera(self):\\n pose = deepcopy(self.data['poses']['marker']) # PoseStamped()\\n eye_pose = deepcopy(pose)\\n eye_pose.pose.position.x += 0.60\\n eye_pose.pose.position.z += 0.20\\n focus_pose = PoseStamped()\\n base_eye_pose = PoseStamped()\\n\\n try:\\n # Convert pose to base frame\\n pose.header.stamp = self.tfl. \\\\\\n getLatestCommonTime(self.params['world'], pose.header.frame_id)\\n focus_pose = self.tfl.transformPose(self.params['world'], pose)\\n except (TfE, LookupException, ConnectivityException):\\n Me.error_message(\\\"Error transforming pose \\\" + pose.header.frame_id)\\n\\n try:\\n # Convert pose to base frame\\n pose.header.stamp = self.tfl. \\\\\\n getLatestCommonTime(self.params['world'],\\n eye_pose.header.frame_id)\\n base_eye_pose = self.tfl.transformPose(self.params['world'],\\n eye_pose)\\n except (TfE, LookupException, ConnectivityException):\\n Me.error_message(\\\"Error transforming pose \\\" + pose.header.frame_id)\\n\\n cam_place = CameraPlacement()\\n cam_place.target_frame = self.params['world']\\n cam_place.time_from_start = Duration(1)\\n # Position of the camera relative to target_frame\\n cam_place.eye.header.frame_id = cam_place.target_frame\\n cam_place.eye.point = base_eye_pose.pose.position\\n # Target_frame-relative point for the focus\\n cam_place.focus.header.frame_id = cam_place.target_frame\\n cam_place.focus.point = focus_pose.pose.position\\n # Target_frame-relative vector that maps to \\\"up\\\" in the view plane.\\n cam_place.up.header.frame_id = cam_place.target_frame\\n cam_place.up.vector.x = 0\\n cam_place.up.vector.y = 0\\n cam_place.up.vector.z = 1\\n self.pub.publish(cam_place)\\n return\",\n \"def camera_frame_directions(self) -> _BFRAME_TYPE:\\n pass\",\n \"def __init__(self, camera):\\n self.__camera = camera\\n self.__innerOrientationParameters = None\\n self.__isSolved = False\\n self.__exteriorOrientationParameters = np.array([0, 0, 0, 0, 0, 0], 'f')\\n self.__rotationMatrix = None\",\n \"def read(self):\\r\\n\\t\\t# get data from camera\\r\\n\\t\\tarray = self.ueye.get_data(self.pcImageMemory, self.width, self.height, self.nBitsPerPixel, self.pitch, copy=False)\\r\\n\\t\\t# get frame as numpy array\\r\\n\\t\\tframe = np.reshape(array,(self.height.value, self.width.value, self.bytes_per_pixel))\\r\\n\\t\\t\\r\\n\\t\\t\\\"\\\"\\\"\\r\\n\\t\\tcamera_matrix = np.array([\\r\\n\\t\\t\\t[4.5330796457901283e+02, 0., 6.1902229288626302e+02],\\r\\n\\t\\t\\t[0., 4.5369175559310276e+02, 5.1298362120979994e+02],\\r\\n\\t\\t\\t[0., 0., 1.]])\\r\\n\\t\\t\\r\\n\\t\\tdist_coeffs = np.array([\\r\\n\\t\\t\\t-3.1812973406286371e-01, 9.6396352148682182e-02,\\r\\n\\t\\t\\t2.9601124432187590e-03, 9.7700591472463412e-04,\\r\\n\\t\\t\\t-1.1929681608809075e-02\\r\\n\\t\\t])\\r\\n\\r\\n\\t\\tframe = cv2.undistort(frame, camera_matrix, dist_coeffs, camera_matrix)\\r\\n\\t\\t\\\"\\\"\\\"\\r\\n\\r\\n\\t\\treturn frame\",\n \"def snapFrame(camera):\\n return camera.read()[1]\",\n \"def get_frame(self, camera: int = 0) -> Tuple[float, np.ndarray]:\\n result = self.video.read()\\n if result[0]:\\n return result\\n else: # If we reach the end of the video, go back to the beginning.\\n self.video.set(cv2.CAP_PROP_POS_FRAMES, 0)\\n return self.video.read()\",\n \"def get_render_obs(self):\\n x, y, z = self.robot.body_xyz\\n\\n if self.camera_type == 'follow':\\n cameraEyePosition = [x, y-1.25, 1.0]\\n cameraTargetPosition = [x, y, 1.0]\\n elif self.camera_type == 'fixed':\\n # y-2.7 not 2.5 since cheetah is longer\\n cameraEyePosition = [2.0, y-2.7, 1.0]\\n cameraTargetPosition = [2.0, y, 1.0]\\n\\n cameraUpVector = [0, 0, 1]\\n\\n fov = 90\\n aspect = self.render_dims[0] / self.render_dims[1]\\n nearPlane = 0.05 # this ensures outside body, may see limbs\\n farPlane = 100.0\\n\\n viewMatrix = p.computeViewMatrix(cameraEyePosition, cameraTargetPosition, cameraUpVector, physicsClientId=self.physicsClientId)\\n projectionMatrix = p.computeProjectionMatrixFOV(fov, aspect, nearPlane, farPlane);\\n img_arr = p.getCameraImage(self.render_dims[0], self.render_dims[1], viewMatrix, projectionMatrix, renderer=p.ER_BULLET_HARDWARE_OPENGL, physicsClientId=self.physicsClientId)\\n\\n rgb=img_arr[2] #color data RGB\\n gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)\\n gray = gray.reshape((1, *self.render_dims))\\n gray[gray > 0] = 255\\n\\n # assign patch at bottom to show distance, this is to differentiate frames\\n # bar_width_pix = int(y/5.0*self.render_dims[1])\\n # bar_height_pix = 10\\n # gray[0][self.render_dims[0]-bar_height_pix:, 0:bar_width_pix] = 255\\n return gray\",\n \"def decompose_essential_matrix(E, x1, x2):\\n\\n # Fix left camera-matrix\\n Rl = np.eye(3)\\n tl = np.array([[0, 0, 0]]).T\\n Pl = np.concatenate((Rl, tl), axis=1)\\n\\n # TODO: Compute possible rotations and translations\\n \\n # s must be [1, 1, 0]\\n u, s, vh = np.linalg.svd(E)\\n E = u @ np.diag([1, 1, 0]) @ vh\\n u, s, vh = np.linalg.svd(E)\\n\\n w = np.array([[ 0, 1, 0], \\n [-1, 0, 0], \\n [ 0, 0, 1]]) \\n \\n z = np.array([[ 0, -1, 0], \\n [ 1, 0, 0],\\n [ 0, 0, 0]])\\n \\n R1 = u @ w.T @ vh\\n s1 = -u @ z @ u.T\\n R2 = u @ w @ vh\\n s2 = u @ z @ u.T\\n\\n t1 = np.array([[s1[2, 1]], \\n [s1[0, 2]],\\n [s1[1, 0]]])\\n \\n t2 = np.array([[s2[2, 1]], \\n [s2[0, 2]], \\n [s2[1, 0]]]) \\n\\n # Four possibilities\\n Pr = [np.concatenate((R1, t1), axis=1),\\n np.concatenate((R1, t2), axis=1),\\n np.concatenate((R2, t1), axis=1),\\n np.concatenate((R2, t2), axis=1)]\\n\\n # Compute reconstructions for all possible right camera-matrices\\n X3Ds = [infer_3d(x1[:, 0:1], x2[:, 0:1], Pl, x) for x in Pr]\\n\\n # Compute projections on image-planes and find when both cameras see point\\n test = [np.prod(np.hstack((Pl @ np.vstack((X3Ds[i], [[1]])), Pr[i] @ np.vstack((X3Ds[i], [[1]])))) > 0, 1) for i in\\n range(4)]\\n test = np.array(test)\\n idx = np.where(np.hstack((test[0, 2], test[1, 2], test[2, 2], test[3, 2])) > 0.)[0][0]\\n\\n # Choose correct matrix\\n Pr = Pr[idx]\\n\\n return Pl, Pr\",\n \"def r2n2_cam2world(self):\\n if not hasattr(self, '_r2n2_cam2world'):\\n ms = []\\n for i in range(24):\\n cam2v1 = assert_is_4x4(self.r2n2_cam2v1[i, ...])\\n v12occnet = assert_is_4x4(self.v12occnet)\\n occnet2gaps = assert_is_4x4(self.occnet2gaps)\\n cam2occnet = np.matmul(v12occnet, cam2v1)\\n cam2gaps = np.matmul(occnet2gaps, cam2occnet)\\n ms.append(assert_is_4x4(cam2gaps))\\n self._r2n2_cam2world = np.stack(ms).astype(np.float32)\\n return self._r2n2_cam2world\",\n \"def worldToCameraCentricXform(self):\\n return self.rotateAlignXform().dot(self.translateToOriginXform())\",\n \"def pixel2cam(self, depth, intrinsics_inv):\\n b, _, h, w = depth.size()\\n i_range = torch.arange(0, h).view(1, h, 1).expand(1,h,w).type_as(depth) # [1, H, W]\\n j_range = torch.arange(0, w).view(1, 1, w).expand(1,h,w).type_as(depth) # [1, H, W]\\n ones = torch.ones(1,h,w).type_as(depth)\\n pixel_coords = torch.stack((j_range, i_range, ones), dim=1) # [1, 3, H, W]\\n ###pixel_coords is an array of camera pixel coordinates (x,y,1) where x,y origin is the upper left corner of the image.\\n current_pixel_coords = pixel_coords[:,:,:h,:w].expand(b,3,h,w).view(b,3,-1) #.contiguous().view(b, 3, -1) # [B, 3, H*W]\\n #cam_coords = intrinsic_inv.expand(b,3,3).bmm(current_pixel_coords).view(b,3,h,w)\\n cam_coords = intrinsics_inv.bmm(current_pixel_coords).view(b,3,h,w)\\n return cam_coords * depth\",\n \"def get_camera_orientation(self):\\n\\n # Create the vector from the camera to the robot\\n vector_x = self.robot_x - self.camera_x\\n vector_y = self.robot_y - self.camera_y\\n vector_z = self.robot_z - self.camera_z\\n\\n # Calculate yaw and pitch from this vector\\n yaw = math.atan2(vector_y, vector_x)\\n pitch = -math.asin(vector_z)\\n\\n # Create the quaternion from the euler angles\\n self.quaternion = geometry_msgs.msg.Quaternion(\\n *tf_conversions.transformations.quaternion_from_euler(0, pitch, yaw))\",\n \"def get_frame_root_rot(self, frame):\\n root_rot = frame[self.POS_SIZE:(self.POS_SIZE + self.ROT_SIZE)].copy()\\n return root_rot\",\n \"def getDejaVuMatrix(self):\\n mtx = self.getRotMatrix((4, 4), transpose=None) # from Quaternion\\n mtx[3] = self.getTranslation()\\n mtx[:3, 3] = mtx[3, :3]\\n mtx[3, :3] = [0, 0, 0]\\n return mtx\",\n \"def translate_frame(frame, x, y):\\n trans_mat = np.float32([[1, 0, x], [0, 1, y]])\\n dimensions = (frame.shape[1], frame.shape[0])\\n return cv.warpAffine(frame, trans_mat, dimensions)\",\n \"def complex_camera(camera, target_rect):\\n l, t, _, _ = target_rect\\n _, _, w, h = camera\\n l, t, _, _ = -l+300, -t+300, w, h\\n\\n l = min(0, l)\\n l = max(-(camera.width-600), l)\\n t = max(-(camera.height-600), t)\\n t = min(0, t)\\n\\n return pygame.Rect(l, t, w, h)\",\n \"def rotate_to_local(self,vxyz):\\n return sp.mxv(self.mtxtofov,vxyz)\",\n \"def get_image(self):\\n self.flush_buffer()\\n _, frame = self.cam.read()\\n shift_frame = self.perspective_shift(frame)\\n #shift_frame = None\\n return frame, shift_frame\",\n \"def get_transform(self, from_frame, to_frame):\\n if not self._pipeline:\\n return None\\n try:\\n from_ind = self._get_frame_index(from_frame)\\n except ValueError:\\n raise CoordinateFrameError(\\\"Frame {0} is not in the available \\\"\\n \\\"frames\\\".format(from_frame))\\n try:\\n to_ind = self._get_frame_index(to_frame)\\n except ValueError:\\n raise CoordinateFrameError(\\\"Frame {0} is not in the available frames\\\".format(to_frame))\\n if to_ind < from_ind:\\n #transforms = np.array(self._pipeline[to_ind: from_ind], dtype=\\\"object\\\")[:, 1].tolist()\\n transforms = [step.transform for step in self._pipeline[to_ind: from_ind]]\\n transforms = [tr.inverse for tr in transforms[::-1]]\\n elif to_ind == from_ind:\\n return None\\n else:\\n #transforms = np.array(self._pipeline[from_ind: to_ind], dtype=\\\"object\\\")[:, 1].copy()\\n transforms = [step.transform for step in self._pipeline[from_ind: to_ind]]\\n return functools.reduce(lambda x, y: x | y, transforms)\",\n \"def extract_camera_sync(sync, chmap=None):\\n assert(chmap)\\n sr = _get_sync_fronts(sync, chmap['right_camera'])\\n sl = _get_sync_fronts(sync, chmap['left_camera'])\\n sb = _get_sync_fronts(sync, chmap['body_camera'])\\n return {'right': sr.times[::2],\\n 'left': sl.times[::2],\\n 'body': sb.times[::2]}\",\n \"def get_projection_matrix(self, aspect):\\n return self.ptr.get_projection_matrix(aspect)\",\n \"def determine_rotation_matrix(self, origin, angle, scale):\\n # scaling will be ignored at this step\\n rotation_matrix = cv2.getRotationMatrix2D(origin, angle * 180 / np.pi, scale)\\n return rotation_matrix\",\n \"def get_frame(self, camera: int = 0) -> Tuple[float, np.ndarray]:\\n return self.video.read()\",\n \"def simple_camera(camera, target_rect):\\n l, t, _, _ = target_rect\\n _, _, w, h = camera\\n return pygame.Rect(-l+300, -t+300, w, h)\",\n \"def get_frame_joints_vel(self, frame):\\n vel = frame[(self.VEL_SIZE + self.ANG_VEL_SIZE):].copy()\\n return vel\",\n \"def _omni_frame_to_omni_frame_projection(self, agent_rel_pose, agent_rel_mat, uniform_sphere_pixel_coords,\\n sphere_pix_coords_f1, sphere_depth_f1, sphere_feat_f1, agent_rel_pose_cov,\\n image_var_f1, holes_prior, holes_prior_var, batch_size):\\n\\n # Frame 1 #\\n # --------#\\n\\n # combined\\n\\n # B x OH x OW x 3\\n angular_pixel_coords_f1 = ivy.concatenate((sphere_pix_coords_f1, sphere_depth_f1), -1)\\n\\n # sphere coords\\n\\n # B x OH x OW x 3\\n sphere_coords_f1 = \\\\\\n ivy_vision.angular_pixel_to_sphere_coords(angular_pixel_coords_f1, self._pixels_per_degree)\\n\\n # Frame 2 #\\n # --------#\\n\\n # sphere to sphere pixel projection\\n\\n sphere_coords_f2 = ivy_vision.sphere_to_sphere_coords(\\n sphere_coords_f1, agent_rel_mat, [batch_size], self._sphere_img_dims)\\n image_var_f2 = image_var_f1\\n\\n # to angular pixel coords\\n\\n # B x OH x OW x 3\\n angular_pixel_coords_f2 = \\\\\\n ivy_vision.sphere_to_angular_pixel_coords(sphere_coords_f2, self._pixels_per_degree)\\n\\n # constant feature projection\\n\\n # B x OH x OW x (3+F)\\n projected_coords_f2 = ivy.concatenate([angular_pixel_coords_f2] + [sphere_feat_f1], -1)\\n\\n # reshaping to fit quantization dimension requirements\\n\\n # B x (OHxOW) x (3+F)\\n projected_coords_f2_flat = ivy.reshape(projected_coords_f2,\\n [batch_size] + [self._sphere_img_dims[0] * self._sphere_img_dims[1]]\\n + [3 + self._feat_dim])\\n\\n # B x (OHxOW) x (3+F)\\n image_var_f2_flat = ivy.reshape(image_var_f2,\\n [batch_size] + [self._sphere_img_dims[0] * self._sphere_img_dims[1]]\\n + [3 + self._feat_dim])\\n\\n # quantize the projection\\n\\n # B x N x OH x OW x (3+F) # B x N x OH x OW x (3+F)\\n return ivy_vision.quantize_to_image(\\n pixel_coords=projected_coords_f2_flat[..., 0:2],\\n final_image_dims=self._sphere_img_dims,\\n feat=projected_coords_f2_flat[..., 2:],\\n feat_prior=holes_prior,\\n with_db=self._with_depth_buffer,\\n pixel_coords_var=image_var_f2_flat[..., 0:2],\\n feat_var=image_var_f2_flat[..., 2:],\\n pixel_coords_prior_var=holes_prior_var[..., 0:2],\\n feat_prior_var=holes_prior_var[..., 2:],\\n var_threshold=self._var_threshold[:, 0],\\n uniform_pixel_coords=uniform_sphere_pixel_coords,\\n batch_shape=(batch_size,),\\n dev_str=self._dev_str)[0:2]\",\n \"def gen_locate_camera_frame(self, exp_id, left_cam_id, right_cam_id, frame_id):\\n exp = experiment.experiment(new_experiment=False, ts=str(exp_id))\\n room_name = exp.metadata[\\\"room\\\"]\\n if room_name.lower() == \\\"cears\\\":\\n room_id = 1\\n elif room_name.lower() == \\\"computer_lab\\\":\\n room_id = 0\\n\\n devices = self.rooms[room_id][\\\"devices\\\"]\\n devices.sort()\\n\\n fname = str(frame_id) + \\\".png\\\"\\n\\n l_camera_name = os.path.basename(devices[int(left_cam_id)])\\n r_camera_name = os.path.basename(devices[int(right_cam_id)])\\n\\n path_l = os.path.join(self.um.experiment_path(exp_id), \\\"raw\\\", l_camera_name, fname) # noqa: E501\\n\\n path_r = os.path.join(self.um.experiment_path(exp_id), \\\"raw\\\", r_camera_name, fname) # noqa: E501\\n\\n frame_l = cv2.imread(path_l, )\\n frame_r = cv2.imread(path_r, )\\n\\n retval = True\\n\\n if frame_l is None:\\n frame_l = cv2.imread(\\\"flask_app/static/task.jpg\\\")\\n ret_val = False\\n\\n if frame_r is None:\\n frame_r = cv2.imread(\\\"flask_app/static/task.jpg\\\")\\n ret_val = False\\n\\n pattern_shape = (9, 6) # TODO: CHECK THIS\\n grid_size = 30 # TODO: CHECK THIS\\n text_l, corners_l, canvas_l, R_l, t_l = computer_vision.calculate_camera_pose(frame_l, self.K, self.d, pattern_shape=pattern_shape, grid_size=grid_size) # noqa: E501\\n text_r, corners_r, canvas_r, R_r, t_r = computer_vision.calculate_camera_pose(frame_r, self.K, self.d, pattern_shape=pattern_shape, grid_size=grid_size) # noqa: E501\\n \\n T_l = np.eye(4)\\n T_r = np.eye(4)\\n if R_l is not None and R_r is not None:\\n T_l[0:3, 0:3] = R_l\\n T_r[0:3, 0:3] = R_r\\n T_l[0:3, 3] = t_l.ravel()\\n T_r[0:3, 3] = t_r.ravel()\\n\\n T_l = np.eye(4)\\n T_r = np.linalg.inv(T_l).dot(T_r)\\n\\n print T_l\\n print T_r\\n canvas = np.hstack([canvas_l, canvas_r])\\n\\n text = \\\"Left: \\\" + text_l + \\\" Right: \\\" + text_r\\n cv2.putText(canvas, text, (20, 40), cv2.FONT_HERSHEY_SIMPLEX,\\n 1.0, (0, 0, 255), lineType=cv2.LINE_AA)\\n\\n ret, jpeg = cv2.imencode('.jpg', canvas)\\n\\n if ret:\\n img = jpeg.tobytes()\\n else:\\n pass\\n\\n yield (b'--frame\\\\r\\\\n'\\n b'Content-Type: image/png;base64,\\\\r\\\\n\\\\r\\\\n' + img + b'\\\\r\\\\n')\",\n \"def get_bounding_boxes(vehicles, camera):\\n '''\\n bounding_boxes = np.array([ClientSideBoundingBoxes.get_bounding_box(vehicle, camera) for vehicle in vehicles])\\n # filter objects behind camera\\n inscene_indices = np.array([1 if all(bb[:, 2]) > 0 else 0 for bb in bounding_boxes])\\n inscene_indices = np.argwhere(inscene_indices == 1)\\n bounding_boxes_visible = [bb for ]\\n rotations = [vehicle.get_transform().rotation for vehicle in vehicles]\\n rotation_decomposed = np.array([[rotation.yaw, rotation.roll, rotation.pitch] for rotation in rotations])\\n rotations_visible = rotation_decomposed[inscene_indices]\\n return bounding_boxes_visible, rotations_visible\\n '''\\n bounding_boxes = [ClientSideBoundingBoxes.get_bounding_box(vehicle, camera) for vehicle in vehicles]\\n # filter objects behind camera\\n rotations = []\\n for vehicle in vehicles:\\n transform = vehicle.get_transform()\\n rotation = transform.rotation\\n rotations.append([rotation.yaw, rotation.roll, rotation.pitch])\\n inscene_indices = []\\n for i in range(len(bounding_boxes)):\\n bb = bounding_boxes[i]\\n if all(bb[:, 2] > 0):\\n inscene_indices.append(1)\\n else:\\n inscene_indices.append(0) \\n inscene_boxes = [bounding_boxes[i] for i in range(len(bounding_boxes)) if inscene_indices[i] == 1]\\n return inscene_boxes, np.array(rotations)[inscene_indices]\",\n \"def getLocalTransform(animation, jointlock, frame, pointpos, handthick = 3.5):\\n jointTransform = jointlock.getGlobalTransform(frame)\\n if handthick:\\n jointPosition = np.dot(jointTransform,[0,0,0,1])[:-1]\\n #Find parametric equation to remove hands surface (hand thickness)\\n vec = jointPosition - pointpos\\n distance = np.linalg.norm(vec)\\n t = handthick/distance\\n position = pointpos + t*vec\\n else:\\n position = pointpos\\n jointInverse = mathutils.inverseMatrix(jointTransform)\\n globalTransform = mathutils.matrixTranslation(position[0], position[1], position[2])\\n localTransform = np.dot(jointInverse, globalTransform)\\n return localTransform\",\n \"def get_camera_stationary_frame_difference_skeleton(threshold, sampling_rate):\\n return {\\n 'result': [],\\n 'hyperparameters': {\\n 'threshold': threshold,\\n 'sampling_rate': sampling_rate\\n }\\n }\",\n \"def get_matrix(transform):\\n\\n rotation = transform.rotation\\n location = transform.location\\n c_y = np.cos(np.radians(rotation.yaw))\\n s_y = np.sin(np.radians(rotation.yaw))\\n c_r = np.cos(np.radians(rotation.roll))\\n s_r = np.sin(np.radians(rotation.roll))\\n c_p = np.cos(np.radians(rotation.pitch))\\n s_p = np.sin(np.radians(rotation.pitch))\\n matrix = np.matrix(np.identity(4))\\n matrix[0, 3] = location.x\\n matrix[1, 3] = location.y\\n matrix[2, 3] = location.z\\n matrix[0, 0] = c_p * c_y\\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\\n matrix[1, 0] = s_y * c_p\\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\\n matrix[2, 0] = s_p\\n matrix[2, 1] = -c_p * s_r\\n matrix[2, 2] = c_p * c_r\\n\\n origin = np.array([location.x, location.y, location.z])\\n return matrix, origin\",\n \"def proj_to_velo(calib_data):\\n rect = calib_data[\\\"R0_rect\\\"].reshape(3, 3)\\n velo_to_cam = calib_data[\\\"Tr_velo_to_cam\\\"].reshape(3, 4)\\n inv_rect = np.linalg.inv(rect)\\n inv_velo_to_cam = np.linalg.pinv(velo_to_cam[:, :3])\\n return np.dot(inv_velo_to_cam, inv_rect)\",\n \"def video(perspective_matrix_path, source=\\\"cam\\\", save=False, save_path=None, file_name=\\\"out\\\", cam_cal=None):\\n if not os.path.isfile(perspective_matrix_path):\\n raise FileNotFoundError(\\\"Path to perspective matrix file not exist!\\\")\\n\\n with open(perspective_matrix_path, \\\"rb\\\") as p:\\n perspective_matrix = pickle.load(p)\\n M = perspective_matrix[\\\"M\\\"]\\n Minv = perspective_matrix[\\\"Minv\\\"]\\n\\n if source == \\\"cam\\\":\\n cap = cv2.VideoCapture(0)\\n else:\\n if not os.path.isfile(source):\\n raise FileNotFoundError(source, \\\" not Exist!\\\")\\n cap = cv2.VideoCapture(source)\\n\\n # camera calibration parameters [ mtx , dist]\\n mtx = None\\n dist = None\\n\\n out = None\\n if save:\\n if not os.path.isdir(save_path):\\n raise FileNotFoundError(save_path, \\\" Not Exist!\\\")\\n file_name += \\\".mp4\\\"\\n out = cv2.VideoWriter(save_path + file_name, -1, 20, (int(cap.get(3)), int(cap.get(4))))\\n\\n if cam_cal:\\n if not os.path.isfile(cam_cal):\\n raise FileNotFoundError(cam_cal, \\\" Not Exist!\\\")\\n\\n with open(cam_cal, \\\"rb\\\") as p:\\n calibration = pickle.load(p)\\n mtx = calibration[\\\"mtx\\\"]\\n dist = calibration[\\\"dist\\\"]\\n\\n left_line = Line(5)\\n right_line = Line(5)\\n\\n while True:\\n # Capture frame-by-frame\\n ret, frame = cap.read()\\n if not ret:\\n print(\\\"Finished..\\\")\\n sys.exit(0)\\n\\n # cv2 read frame as BGR, convert it to RGB\\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\\n\\n # camera calibration\\n if not (mtx is None or dist is None):\\n frame = cv2.undistort(frame, mtx, dist, None, mtx)\\n\\n # get edges in image\\n edges = apply_edge_detection(frame)\\n\\n # transform image to bird view\\n warped = warped_img(edges, M)\\n\\n # init out image which will draw lane line on it then weight it with original frame\\n out_img = np.zeros_like(warped)\\n if len(warped.shape) == 3 and warped.shape[2] == 3:\\n pass\\n else:\\n out_img = np.dstack((out_img, out_img, out_img))\\n\\n # if line not detected, apply sliding window\\n if not left_line.detected or not right_line.detected:\\n leftx, lefty, rightx, righty = sliding_window(warped, 9, 200)\\n\\n # if already detected apply search around detected line\\n else:\\n leftx, lefty = search_around_poly(left_line, warped)\\n rightx, righty = search_around_poly(right_line, warped)\\n\\n # will used for plotting line, find x fitted\\n ploty = np.linspace(warped.shape[0] // 4, warped.shape[0] - 1, warped.shape[0])\\n\\n # check if at least 100 pixels detected as line\\n if len(leftx) > 100 and len(rightx) > 100:\\n\\n # make detected flag true\\n left_line.detected = True\\n right_line.detected = True\\n\\n left_line.current_x = leftx\\n left_line.current_y = lefty\\n\\n right_line.current_x = rightx\\n right_line.current_y = righty\\n\\n left_line.fit_polynomial(ploty)\\n right_line.fit_polynomial(ploty)\\n\\n else:\\n print(\\\"Line not detected in this frame \\\")\\n # we just draw line form previous frame\\n\\n # make detected flag true\\n left_line.detected = False\\n right_line.detected = False\\n\\n # update Lane line radius\\n left_line.radius()\\n right_line.radius()\\n\\n # avg radius of to lines, and plot it\\n radius = (left_line.radius_of_curvature + right_line.radius_of_curvature) // 2\\n frame = write_text(frame, \\\"Radius of Curvature = \\\" + str(radius) + \\\" M\\\", pos=(20, 50))\\n\\n # calculate Alignment ( how much car away from center between Lane lines\\n dir = \\\"Left\\\" # car far from left or right\\n\\n left_line.car_offset(frame.shape) # distance from left line\\n right_line.car_offset(frame.shape) # distance from right line\\n\\n distance = round(right_line.line_base_pos - left_line.line_base_pos, 2)\\n\\n if distance < 0: # car far away from left line not right line\\n distance = -distance\\n dir = \\\"Right\\\"\\n frame = write_text(frame, \\\"Vehicle is {}m {} of center\\\".format(distance, dir), pos=(20, 80))\\n\\n # ** plot lane lines on image **\\n # left_line.draw_line(out_img, ploty)\\n # right_line.draw_line(out_img, ploty)\\n\\n # color pixel which belong to lane lines\\n left_line.color_pixel(out_img, (255, 0, 0))\\n right_line.color_pixel(out_img, (255, 100, 0))\\n\\n # fit green triangle in area between lane lines\\n pts_left = np.array([np.transpose(np.vstack([left_line.bestx, ploty]))])\\n pts_right = np.array([np.flipud(np.transpose(np.vstack([right_line.bestx, ploty])))])\\n pts = np.hstack((pts_left, pts_right))\\n\\n # Draw the lane onto the warped blank image\\n cv2.fillPoly(out_img, np.int_([pts]), (0, 255, 0))\\n\\n # return image to normal view from bird view\\n out_img_undit = warped_img(out_img, Minv)\\n\\n # weight out_image_undit with original frame\\n frame = cv2.addWeighted(out_img_undit, 0.5, frame, 1, 0)\\n frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)\\n\\n cv2.imshow(\\\"frame\\\", frame)\\n\\n # write video\\n if save:\\n out.write(frame)\\n if cv2.waitKey(1) & 0xFF == ord('q'):\\n break\\n\\n # When everything done, release the capture\\n cap.release()\\n cv2.destroyAllWindows()\",\n \"def base_projection_matrix(self, fiber):\\n return matrix(ZZ, fiber.vertices()).right_kernel_matrix()\",\n \"def get_world_rot(m_obj):\\n plug = get_world_matrix_plug(m_obj, 0)\\n matrix_obj = plug.asMObject()\\n matrix_data = oMa.MFnMatrixData(matrix_obj)\\n matrix = matrix_data.matrix()\\n\\n trans_matrix = oMa.MTransformationMatrix(matrix)\\n rot = trans_matrix.rotation()\\n\\n return rot\",\n \"def transform(orbit, frame_orig, frame_dest):\\n\\n orbit_orig = frame_orig(\\n x=orbit.r[0],\\n y=orbit.r[1],\\n z=orbit.r[2],\\n v_x=orbit.v[0],\\n v_y=orbit.v[1],\\n v_z=orbit.v[2],\\n representation=CartesianRepresentation,\\n differential_type=CartesianDifferential,\\n )\\n\\n orbit_dest = orbit_orig.transform_to(frame_dest(obstime=orbit.epoch))\\n orbit_dest.representation = CartesianRepresentation\\n\\n return Orbit.from_vectors(\\n orbit.attractor,\\n orbit_dest.data.xyz,\\n orbit_dest.data.differentials[\\\"s\\\"].d_xyz,\\n epoch=orbit.epoch,\\n )\",\n \"def calc_transform(src_, dst_):\\n M_ = cv2.getPerspectiveTransform(src_, dst_)\\n Minv_ = cv2.getPerspectiveTransform(dst_, src_)\\n return M_, Minv_\",\n \"def copy(self):\\n return CameraExtrinsic(self.position, self.direction, self.up)\",\n \"def __parseFrameSpherical(self):\\n print(\\\"pointcloud: starting the frame parsing\\\")\\n pointArray = []\\n for (y, row) in enumerate(self.frame):\\n #trim hfov\\n pixelWidth = len(row)\\n deltaAngle = self.rawhfov - self.desiredhfov\\n pixelsToRemove = pixelWidth / deltaAngle \\n row = row[int(ceil(pixelsToRemove/2)) : pixelWidth-int(ceil(pixelsToRemove/2)) ]\\n \\n for x, depth in enumerate(row):\\n if(depth == 0):\\n continue\\n width = float(len(row))\\n height = float(len(self.frame))\\n thetax = (pi/2) - radians((self.rawhfov / width) * x)\\n thetay = (pi/2) - radians((self.vfov / height) * y)\\n vx = float(cos(thetax) * sin(thetay) * depth)\\n vy = float(sin(thetax) * sin(thetay) * depth)\\n vz = float(cos(thetay) * depth)\\n vector3 = [vx, vy, vz]\\n pointArray.append(vector3)\\n self.points = pointArray\\n print(\\\"pointcloud: ended the frame parsing\\\")\",\n \"def cam_to_body(self, vector):\\n cam2hand = generate_frame_transform(self._cam2hand_t[0:3,:],self._cam2hand_R[0:3,0:3],False)\\n # Possibly GRASP specific function?\\n hand_pose = baxter.get_right_arm_pose()\\n (t,R) = get_t_R(hand_pose)\\n hand2body = generate_frame_transform(t[0:3,:],R[0:3,0:3],True)\\n return np.dot(hand2body,np.dot(cam2hand,vector))\",\n \"def _frame_to_omni_frame_projection(self, cam_rel_poses, cam_rel_mats, uniform_sphere_pixel_coords, cam_coords_f1,\\n cam_feat_f1, rel_pose_covs, image_var_f1, holes_prior, holes_prior_var,\\n batch_size, num_timesteps, num_cams, image_dims):\\n\\n # cam 1 to cam 2 coords\\n\\n cam_coords_f2 = ivy_vision.cam_to_cam_coords(\\n ivy_mech.make_coordinates_homogeneous(\\n cam_coords_f1, [batch_size, num_timesteps, num_cams] + image_dims), cam_rel_mats,\\n [batch_size, num_timesteps, num_cams], image_dims)\\n\\n # cam 2 to sphere 2 coords\\n\\n sphere_coords_f2 = ivy_vision.cam_to_sphere_coords(cam_coords_f2)\\n image_var_f2 = image_var_f1\\n\\n # angular pixel coords\\n\\n # B x N x C x H x W x 3\\n angular_pixel_coords_f2 = \\\\\\n ivy_vision.sphere_to_angular_pixel_coords(sphere_coords_f2, self._pixels_per_degree)\\n\\n # constant feature projection\\n\\n # B x N x C x H x W x (3+F)\\n projected_coords_f2 = ivy.concatenate([angular_pixel_coords_f2] + [cam_feat_f1], -1)\\n\\n # reshaping to fit quantization dimension requirements\\n\\n # B x N x (CxHxW) x (3+F)\\n projected_coords_f2_flat = \\\\\\n ivy.reshape(projected_coords_f2,\\n [batch_size, num_timesteps, num_cams * image_dims[0] * image_dims[1], -1])\\n\\n # B x N x (CxHxW) x (3+F)\\n image_var_f2_flat = ivy.reshape(image_var_f2,\\n [batch_size, num_timesteps, num_cams * image_dims[0] * image_dims[1], -1])\\n\\n # quantized result from all scene cameras\\n\\n # B x N x OH x OW x (3+F) # B x N x OH x OW x (3+F)\\n return ivy_vision.quantize_to_image(\\n pixel_coords=projected_coords_f2_flat[..., 0:2],\\n final_image_dims=self._sphere_img_dims,\\n feat=projected_coords_f2_flat[..., 2:],\\n feat_prior=holes_prior,\\n with_db=self._with_depth_buffer,\\n pixel_coords_var=image_var_f2_flat[..., 0:2],\\n feat_var=image_var_f2_flat[..., 2:],\\n pixel_coords_prior_var=holes_prior_var[..., 0:2],\\n feat_prior_var=holes_prior_var[..., 2:],\\n var_threshold=self._var_threshold,\\n uniform_pixel_coords=uniform_sphere_pixel_coords,\\n batch_shape=(batch_size, num_timesteps),\\n dev_str=self._dev_str)[0:2]\",\n \"def projection_matrix(self):\\n scene = self.figure.scene\\n scene_size = tuple(scene.get_size())\\n aspect_ratio = float(scene_size[0]) / float(scene_size[1])\\n p = scene.camera.get_perspective_transform_matrix(\\n aspect_ratio, -1, 1).to_array().astype(np.float32)\\n return p\",\n \"def get_M(self, theta, phi, gamma, dx, dy, dz):\\n w = self.width\\n h = self.height\\n f = self.focal\\n # Projection 2D -> 3D matrix\\n A1 = np.array([[1, 0, -w / 2],\\n [0, 1, -h / 2],\\n [0, 0, 1],\\n [0, 0, 1]])\\n # Rotation matrices around the X, Y, and Z axis\\n RX = np.array([[1, 0, 0, 0],\\n [0, np.cos(theta), -np.sin(theta), 0],\\n [0, np.sin(theta), np.cos(theta), 0],\\n [0, 0, 0, 1]])\\n RY = np.array([[np.cos(phi), 0, -np.sin(phi), 0],\\n [0, 1, 0, 0],\\n [np.sin(phi), 0, np.cos(phi), 0],\\n [0, 0, 0, 1]])\\n RZ = np.array([[np.cos(gamma), -np.sin(gamma), 0, 0],\\n [np.sin(gamma), np.cos(gamma), 0, 0],\\n [0, 0, 1, 0],\\n [0, 0, 0, 1]])\\n # Composed rotation matrix with (RX, RY, RZ)\\n R = np.dot(np.dot(RX, RY), RZ)\\n # Translation matrix\\n T = np.array([[1, 0, 0, dx],\\n [0, 1, 0, dy],\\n [0, 0, 1, dz],\\n [0, 0, 0, 1]])\\n # Projection 3D -> 2D matrix\\n A2 = np.array([[f, 0, w / 2, 0],\\n [0, f, h / 2, 0],\\n [0, 0, 1, 0]])\\n # Final transformation matrix\\n return np.dot(A2, np.dot(T, np.dot(R, A1)))\",\n \"def export_camera(file, scene, global_matrix, render, tab_write):\\n camera = scene.camera\\n\\n # DH disabled for now, this isn't the correct context\\n active_object = None # bpy.context.active_object # does not always work MR\\n matrix = global_matrix @ camera.matrix_world\\n focal_point = camera.data.dof.focus_distance\\n\\n # compute resolution\\n q_size = render.resolution_x / render.resolution_y\\n tab_write(file, \\\"#declare camLocation = <%.6f, %.6f, %.6f>;\\\\n\\\" % matrix.translation[:])\\n tab_write(\\n file,\\n (\\n \\\"#declare camLookAt = <%.6f, %.6f, %.6f>;\\\\n\\\"\\n % tuple(degrees(e) for e in matrix.to_3x3().to_euler())\\n ),\\n )\\n\\n tab_write(file, \\\"camera {\\\\n\\\")\\n if scene.pov.baking_enable and active_object and active_object.type == \\\"MESH\\\":\\n tab_write(file, \\\"mesh_camera{ 1 3\\\\n\\\") # distribution 3 is what we want here\\n tab_write(file, \\\"mesh{%s}\\\\n\\\" % active_object.name)\\n tab_write(file, \\\"}\\\\n\\\")\\n tab_write(file, \\\"location <0,0,.01>\\\")\\n tab_write(file, \\\"direction <0,0,-1>\\\")\\n\\n else:\\n if camera.data.type == \\\"ORTHO\\\":\\n # XXX todo: track when SensorHeightRatio was added to see if needed (not used)\\n sensor_height_ratio = (\\n render.resolution_x * camera.data.ortho_scale / render.resolution_y\\n )\\n tab_write(file, \\\"orthographic\\\\n\\\")\\n # Blender angle is radian so should be converted to degrees:\\n # % (camera.data.angle * (180.0 / pi) )\\n # but actually argument is not compulsory after angle in pov ortho mode\\n tab_write(file, \\\"angle\\\\n\\\")\\n tab_write(file, \\\"right <%6f, 0, 0>\\\\n\\\" % -camera.data.ortho_scale)\\n tab_write(file, \\\"location <0, 0, 0>\\\\n\\\")\\n tab_write(file, \\\"look_at <0, 0, -1>\\\\n\\\")\\n tab_write(file, \\\"up <0, %6f, 0>\\\\n\\\" % (camera.data.ortho_scale / q_size))\\n\\n elif camera.data.type == \\\"PANO\\\":\\n tab_write(file, \\\"panoramic\\\\n\\\")\\n tab_write(file, \\\"location <0, 0, 0>\\\\n\\\")\\n tab_write(file, \\\"look_at <0, 0, -1>\\\\n\\\")\\n tab_write(file, \\\"right <%s, 0, 0>\\\\n\\\" % -q_size)\\n tab_write(file, \\\"up <0, 1, 0>\\\\n\\\")\\n tab_write(file, \\\"angle %f\\\\n\\\" % (360.0 * atan(16.0 / camera.data.lens) / pi))\\n elif camera.data.type == \\\"PERSP\\\":\\n # Standard camera otherwise would be default in pov\\n tab_write(file, \\\"location <0, 0, 0>\\\\n\\\")\\n tab_write(file, \\\"look_at <0, 0, -1>\\\\n\\\")\\n tab_write(file, \\\"right <%s, 0, 0>\\\\n\\\" % -q_size)\\n tab_write(file, \\\"up <0, 1, 0>\\\\n\\\")\\n tab_write(\\n file,\\n \\\"angle %f\\\\n\\\"\\n % (2 * atan(camera.data.sensor_width / 2 / camera.data.lens) * 180.0 / pi),\\n )\\n\\n tab_write(\\n file,\\n \\\"rotate <%.6f, %.6f, %.6f>\\\\n\\\" % tuple(degrees(e) for e in matrix.to_3x3().to_euler()),\\n )\\n\\n tab_write(file, \\\"translate <%.6f, %.6f, %.6f>\\\\n\\\" % matrix.translation[:])\\n if camera.data.dof.use_dof and (focal_point != 0 or camera.data.dof.focus_object):\\n tab_write(\\n file, \\\"aperture %.3g\\\\n\\\" % (1 / (camera.data.dof.aperture_fstop * 10000) * 1000)\\n )\\n tab_write(\\n file,\\n \\\"blur_samples %d %d\\\\n\\\"\\n % (camera.data.pov.dof_samples_min, camera.data.pov.dof_samples_max),\\n )\\n tab_write(file, \\\"variance 1/%d\\\\n\\\" % camera.data.pov.dof_variance)\\n tab_write(file, \\\"confidence %.3g\\\\n\\\" % camera.data.pov.dof_confidence)\\n if camera.data.dof.focus_object:\\n focal_ob = scene.objects[camera.data.dof.focus_object.name]\\n matrix_blur = global_matrix @ focal_ob.matrix_world\\n tab_write(file, \\\"focal_point <%.4f,%.4f,%.4f>\\\\n\\\" % matrix_blur.translation[:])\\n else:\\n tab_write(file, \\\"focal_point <0, 0, %f>\\\\n\\\" % focal_point)\\n if camera.data.pov.normal_enable:\\n tab_write(\\n file,\\n \\\"normal {%s %.4f turbulence %.4f scale %.4f}\\\\n\\\"\\n % (\\n camera.data.pov.normal_patterns,\\n camera.data.pov.cam_normal,\\n camera.data.pov.turbulence,\\n camera.data.pov.scale,\\n ),\\n )\\n tab_write(file, \\\"}\\\\n\\\")\",\n \"def _calculate_camera_array(self):\\n look_list = []\\n\\n row_step_vec = normalize(self.look_up) * self.interspatial_distance\\n col_step_vec = self._get_look_right() * self.interspatial_distance\\n\\n # Start at the top left camera position\\n for i in range(self.spatial_rows):\\n row_movement = row_step_vec * (-i)\\n row_look_from = self.look_from + row_movement\\n row_look_to = self.look_to + row_movement\\n\\n for j in range(self.spatial_cols):\\n col_movement = col_step_vec * j\\n cam_look_from = row_look_from + col_movement\\n cam_look_to = row_look_to + col_movement\\n\\n look_list.append((cam_look_from, cam_look_to))\\n\\n return look_list\",\n \"def publish_camera_frame(self):\\n executive.get_camera_orientation()\\n self.t.start()\\n # Wait for transformation to be published\\n rospy.sleep(2)\",\n \"def perspective_transform():\\n src = np.float32([(220,720), (1110, 720), (570, 470), (722, 470)]) # Manually get these numbers from plot\\n dst = np.float32([[320, 720], [920, 720], [320, 1], [920, 1]])\\n M = cv2.getPerspectiveTransform(src, dst)\\n Minv = cv2.getPerspectiveTransform(dst, src)\\n\\n return M, Minv\",\n \"def _calculate_camera_pose(frame, K, d, corners, pattern_shape=(6, 4), grid_size=30): # noqa: E501\\n img = frame.copy()\\n axis = np.float32([[grid_size, 0, 0], [0, grid_size, 0],\\n [0, 0, -grid_size]]).reshape(-1, 3)*2\\n\\n objp = np.zeros((np.prod(pattern_shape), 3), np.float32)\\n objp[:, :2] = np.mgrid[0:pattern_shape[0],\\n 0:pattern_shape[1]].T.reshape(-1, 2) * grid_size\\n\\n _, rvecs, tvecs = cv2.solvePnP(objp, corners, K, d)\\n R, _ = cv2.Rodrigues(rvecs)\\n # project 3D points onto image plane\\n imgpts, _ = cv2.projectPoints(axis,\\n rvecs, tvecs,\\n K, d)\\n\\n canvas = computer_vision.draw_axis(img, corners, imgpts)\\n return R, tvecs, canvas\",\n \"def query_camera(self):\\n ok, orig_pic = self.vs.read() # Read video stream\\n if ok: # If no errors\\n orig_pic = imutils.rotate(orig_pic, angle=self.camera_rot)\\n curr_pic = imutils.resize(orig_pic, width=self.image_width)\\n return curr_pic, orig_pic\\n else:\\n return None, None\",\n \"def transMatrix( source=None ):\\n if source is None:\\n return None,None\\n else:\\n (x,y,z) = source[:3]\\n if x == y == z == 0.0:\\n return None, None \\n return tmatrixaccel.transMatrix( x,y,z ),tmatrixaccel.transMatrix( -x, -y, -z )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.653753","0.6497488","0.6299928","0.62356544","0.61046827","0.60589045","0.60228235","0.5942271","0.5935986","0.5927937","0.5889109","0.58773947","0.58653027","0.5864766","0.5847944","0.58465064","0.5835871","0.5828304","0.57876843","0.5779836","0.5772962","0.5770148","0.5765084","0.57462746","0.57462454","0.5741935","0.5724905","0.5662365","0.5619435","0.5584499","0.5577126","0.55650276","0.55534947","0.55207044","0.5518501","0.55038434","0.5487898","0.5474158","0.5439808","0.5418603","0.5416651","0.5413313","0.5397355","0.53836036","0.5351097","0.53421444","0.533866","0.5331934","0.53237665","0.5323134","0.53219324","0.5312476","0.5303562","0.5299455","0.52988386","0.5289084","0.52846175","0.5273258","0.5264596","0.5256064","0.5253539","0.52508336","0.5244755","0.5243597","0.5228789","0.5227275","0.52129406","0.51838034","0.51815265","0.5168","0.5166467","0.5160764","0.5146032","0.5142636","0.5139099","0.51204526","0.51004064","0.50978196","0.50930643","0.5092066","0.509138","0.5083791","0.5077928","0.50715184","0.5070569","0.50667727","0.5063481","0.50499946","0.5047451","0.50457287","0.50439996","0.50398993","0.50326836","0.5026103","0.5025114","0.5020177","0.5016095","0.49941266","0.49790922","0.49757993","0.49747086"],"string":"[\n \"0.653753\",\n \"0.6497488\",\n \"0.6299928\",\n \"0.62356544\",\n \"0.61046827\",\n \"0.60589045\",\n \"0.60228235\",\n \"0.5942271\",\n \"0.5935986\",\n \"0.5927937\",\n \"0.5889109\",\n \"0.58773947\",\n \"0.58653027\",\n \"0.5864766\",\n \"0.5847944\",\n \"0.58465064\",\n \"0.5835871\",\n \"0.5828304\",\n \"0.57876843\",\n \"0.5779836\",\n \"0.5772962\",\n \"0.5770148\",\n \"0.5765084\",\n \"0.57462746\",\n \"0.57462454\",\n \"0.5741935\",\n \"0.5724905\",\n \"0.5662365\",\n \"0.5619435\",\n \"0.5584499\",\n \"0.5577126\",\n \"0.55650276\",\n \"0.55534947\",\n \"0.55207044\",\n \"0.5518501\",\n \"0.55038434\",\n \"0.5487898\",\n \"0.5474158\",\n \"0.5439808\",\n \"0.5418603\",\n \"0.5416651\",\n \"0.5413313\",\n \"0.5397355\",\n \"0.53836036\",\n \"0.5351097\",\n \"0.53421444\",\n \"0.533866\",\n \"0.5331934\",\n \"0.53237665\",\n \"0.5323134\",\n \"0.53219324\",\n \"0.5312476\",\n \"0.5303562\",\n \"0.5299455\",\n \"0.52988386\",\n \"0.5289084\",\n \"0.52846175\",\n \"0.5273258\",\n \"0.5264596\",\n \"0.5256064\",\n \"0.5253539\",\n \"0.52508336\",\n \"0.5244755\",\n \"0.5243597\",\n \"0.5228789\",\n \"0.5227275\",\n \"0.52129406\",\n \"0.51838034\",\n \"0.51815265\",\n \"0.5168\",\n \"0.5166467\",\n \"0.5160764\",\n \"0.5146032\",\n \"0.5142636\",\n \"0.5139099\",\n \"0.51204526\",\n \"0.51004064\",\n \"0.50978196\",\n \"0.50930643\",\n \"0.5092066\",\n \"0.509138\",\n \"0.5083791\",\n \"0.5077928\",\n \"0.50715184\",\n \"0.5070569\",\n \"0.50667727\",\n \"0.5063481\",\n \"0.50499946\",\n \"0.5047451\",\n \"0.50457287\",\n \"0.50439996\",\n \"0.50398993\",\n \"0.50326836\",\n \"0.5026103\",\n \"0.5025114\",\n \"0.5020177\",\n \"0.5016095\",\n \"0.49941266\",\n \"0.49790922\",\n \"0.49757993\",\n \"0.49747086\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":397,"cells":{"query":{"kind":"string","value":"return enantiomer of self, either D or L"},"document":{"kind":"string","value":"def D_or_L(self) -> str:\n CO = np.array([self['C'].xyz.x, self['C'].xyz.y, self['C'].xyz.z])\n CA = np.array([self['CA'].xyz.x, self['CA'].xyz.y, self['CA'].xyz.z])\n CB = np.array([self['CB'].xyz.x, self['CB'].xyz.y, self['CB'].xyz.z])\n N = np.array([self['N'].xyz.x, self['N'].xyz.y, self['N'].xyz.z])\n\n v1 = N - CO\n v2 = CA - CO\n cp = np.cross(v1, v2)\n CB_infront = cp.dot(CB-CA) > 0\n print(CB_infront)\n return 'D' if CB_infront else 'L'"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def L(self):\n if not self.isVaild():\n pass\n return self.Lq() + self.r()","def exterior_der(self):\n from utilities import format_unop_txt, format_unop_latex\n if self._exterior_derivative is None:\n vmodule = self._vmodule # shortcut\n rname = format_unop_txt('d', self._name)\n rlname = format_unop_latex(r'\\mathrm{d}', self._latex_name)\n resu = vmodule.alternating_form(self._tensor_rank+1, name=rname, \n latex_name=rlname)\n for dom, rst in self._restrictions.iteritems():\n resu._restrictions[dom] = rst.exterior_der()\n self._exterior_derivative = resu\n return self._exterior_derivative","def L(self):\n return self._L","def L(self):\n return self.__L","def L(self):\n return self.__L","def L(self):\n return self.__L","def L(self):\n return self.__L","def getL(self):\r\n return self.L","def LDLT(self):\n\t\tpass","def lform(self):\n a, c, d, b = self.to_ccw()\n if b < c:\n a += b\n b -= b\n c -= b\n d += b\n else:\n a += c\n b -= c\n c -= c\n d += c\n return self.__class__.from_ccw(a, c, d, b)","def dilemma(self, disjunction):\n\t\tinterp1 = _match(((A, impl, B), conj, (C, impl, D)), self)\n\t\tinterp2 = _match((A, disj, C), disjunction)\n\t\tif interp1[A] == interp2[A] and interp1[C] == interp2[C]:\n\t\t\treturn self.__class__((interp1[B], disj, interp1[D]))\n\t\telse:\n\t\t\traise LogicException()","def Dang_l(self):\n return self._Dang_l","def either(self):\n return self._v","def dual(self):\n letter = self.letter()\n # the self-dual cases\n if letter != 'BC' and letter[0] in ['B','C']:\n if letter == 'BB': letter = 'CC'\n elif letter == 'CC': letter = 'BB'\n elif letter[0] == 'B': letter = 'C' + letter[1:]\n elif letter[0] == 'C': letter = 'B' + letter[1:]\n rank = self._rank\n if self.is_affine():\n rank -= 1\n twist = self._twist\n return QuiverMutationType(letter,rank,twist)\n # the cases F and G have non-trivial duality in some cases\n elif letter in ['F','G']:\n if self.is_finite(): return self\n elif self.is_affine():\n rank = self._rank - 1\n twist = - self._twist\n elif self.is_elliptic():\n twist = self._twist\n rank = self._rank - 2\n if letter == 'F':\n if self._twist == [2,2]:\n twist == [1,1]\n if self._twist == [1,1]:\n twist == [2,2]\n if letter == 'G':\n if self._twist == [3,3]:\n twist = [1,1]\n elif self._twist == [1,1]:\n twist = [3,3]\n else: rank = self._rank\n return QuiverMutationType(letter,rank,twist)\n else:\n return self","def ewald(self):\n return self._ewald","def getD(self):\r\n return self.D","def _repr_(self):\n return \"Lie algebra %s over %s\" % (self._classification,\n self.base_ring())","def right(self):\n return self.__r","def __le__(self, other):\n if (self.master.__class__.__name__ == 'OneDimGrid') or (issubclass(self.master.__class__, OneDimGrid)):\n return self._le_1d(other=other)\n if (self.master.__class__.__name__ == 'Grid') or (issubclass(self.master.__class__, Grid)):\n return self._le_2d(other=other)","def get_E(self):\r\n return self.E","def right(self):\n return self.r","def l_un_degenerate(self):\n self.right = self.tmp","def __arb__(self):\n if self.tree.total < 1:\n return None\n if self.tree.total % 2 == 0:\n return self.first()\n else:\n return self.last()","def d(self):\n pass","def d(self):\n pass","def __aiter__(self):\n return self","def one_sided(self):\n return self._one_sided","def disagreement(self):\n return 0.5*(np.dot(np.dot(np.transpose(self.x),self.L),self.x)).item(0)","def __invert__(self):\n return type(self)(self.parent(),\n self._simplify(SR.one() / self._express))\n # NB: self._express.__invert__() would return 1/self._express\n # (cf. the code of __invert__ in src/sage/symbolic/expression.pyx)\n # Here we prefer SR(1)/self._express","def get_right(self):\r\n if getattr(self, '_right') is None:\r\n warnings.warn('Hmmm... I will use \"call\" right, since you did not provide any', UserWarning)\r\n self._right = 'call'\r\n\r\n return self._right","def _der(self, x):\n return self._evalOrDer(x, False, True)[0]","def get_E(self):\n return self.E","def leverancier(self):\n return self._leverancier.get_waarde()","def l(self):\n return self._l","def lro(self) -> global___Snippet.Lro:","def solveL(self,level=-1) :\n for g in self.L() :\n if level >= 0 :\n printIndent('%s' % (g,),level=level)\n print \n if g.solveR(level=(level+1) if level>=0 else level) is None : \n return g\n return None","def __invert__(self):\n return self.obj","def fodder(self):\n return self._fodder","def exterior_der(self):\n from sage.calculus.functional import diff\n from utilities import format_unop_txt, format_unop_latex\n from sage.tensor.modules.comp import CompFullyAntiSym\n from vectorframe import CoordFrame\n if self._exterior_derivative is None:\n # A new computation is necessary:\n fmodule = self._fmodule # shortcut\n rname = format_unop_txt('d', self._name)\n rlname = format_unop_latex(r'\\mathrm{d}', self._latex_name)\n self._exterior_derivative = DiffFormParal(fmodule, \n self._tensor_rank+1, \n name=rname, \n latex_name=rlname)\n # 1/ List of all coordinate frames in which the components of self\n # are known\n coord_frames = []\n for frame in self._components:\n if isinstance(frame, CoordFrame):\n coord_frames.append(frame)\n if coord_frames == []:\n # A coordinate frame is searched, at the price of a change of\n # frame, priveleging the frame of the domain's default chart\n dom = self._domain\n def_coordf = dom._def_chart._frame\n for frame in self._components:\n if (frame, def_coordf) in dom._frame_changes:\n self.comp(def_coordf, from_basis=frame)\n coord_frames = [def_coordf]\n break\n if coord_frames == []:\n for chart in dom._atlas:\n if chart != dom._def_chart: # the case def_chart is treated above\n coordf = chart._frame\n for frame in self._components:\n if (frame, coordf) in dom._frame_changes:\n self.comp(coordf, from_basis=frame)\n coord_frames[coordf]\n break\n if coord_frames != []:\n break \n # 2/ The computation:\n for frame in coord_frames:\n chart = frame._chart\n sc = self._components[frame]\n dc = CompFullyAntiSym(fmodule._ring, frame, \n self._tensor_rank+1, \n start_index=fmodule._sindex,\n output_formatter=fmodule._output_formatter)\n for ind, val in sc._comp.iteritems():\n for i in fmodule.irange():\n ind_d = (i,) + ind\n if len(ind_d) == len(set(ind_d)): \n # all indices are different\n dc[[ind_d]] += \\\n val.function_chart(chart).diff(i).scalar_field()\n self._exterior_derivative._components[frame] = dc\n return self._exterior_derivative","def get_right(self):\n return self.__right","def wedge(self, other):\n from sage.tensor.modules.free_module_alt_form import FreeModuleAltForm\n from sage.tensor.modules.format_utilities import is_atomic\n if self._domain.is_subdomain(other._domain):\n if not self._ambient_domain.is_subdomain(other._ambient_domain):\n raise TypeError(\"Incompatible ambient domains for exterior \" + \n \"product.\")\n elif other._domain.is_subdomain(self._domain):\n if not other._ambient_domain.is_subdomain(self._ambient_domain):\n raise TypeError(\"Incompatible ambient domains for exterior \" + \n \"product.\")\n dom_resu = self._domain.intersection(other._domain)\n ambient_dom_resu = self._ambient_domain.intersection(\n other._ambient_domain)\n self_r = self.restrict(dom_resu)\n other_r = other.restrict(dom_resu)\n if ambient_dom_resu.is_manifestly_parallelizable():\n # call of the FreeModuleAltForm version:\n return FreeModuleAltForm.wedge(self_r, other_r)\n # otherwise, the result is created here:\n if self._name is not None and other._name is not None:\n sname = self._name\n oname = other._name\n if not is_atomic(sname):\n sname = '(' + sname + ')'\n if not is_atomic(oname):\n oname = '(' + oname + ')'\n resu_name = sname + '/\\\\' + oname\n if self._latex_name is not None and other._latex_name is not None:\n slname = self._latex_name\n olname = other._latex_name\n if not is_atomic(slname):\n slname = '(' + slname + ')'\n if not is_atomic(olname):\n olname = '(' + olname + ')'\n resu_latex_name = slname + r'\\wedge ' + olname\n dest_map = self._vmodule._dest_map\n dest_map_resu = dest_map.restrict(dom_resu, \n subcodomain=ambient_dom_resu)\n vmodule = dom_resu.vector_field_module(dest_map=dest_map_resu)\n resu_degree = self._tensor_rank + other._tensor_rank\n resu = vmodule.alternating_form(resu_degree, name=resu_name, \n latex_name=resu_latex_name)\n for dom in self_r._restrictions:\n if dom in other_r._restrictions:\n resu._restrictions[dom] = self_r._restrictions[dom].wedge(\n other_r._restrictions[dom])\n return resu","def __or__(self, other):\n raise NotImplementedError(\"failed monkey-patch: material stacker needs\"\n \" to replace __or__ in Scatterer\")","def getLEq(self):\r\n return self.lEq;","def left(self):\n return self.l","def simplify(self):\n return self","def inner_endomorphism(self, multiplier):\n return InnerEndomorphism(self.domain, multiplier)","def __repr__(self):\n\n return f\"Legislator: {self.full_name} party: {self.party}\"","def __call__(self):\r\n return self[-1]","def DOR(self):\n a, c, d, b = self.to_ccw()\n ad, bc = a * d, b * c\n return _div(ad, bc)","def __call__(self):\n return self._left() + self._right()","def get_right(self):\n return self.right","def __invert__(self):\r\n if self.field.characteristic == 2:\r\n return runtime.invert(self)\r\n\r\n return super().__invert__()","def pillar_e_room(self):\r\n return self.__pillar_e","def related(self):\n return self.__class__ != Rol and self or getattr(self, self.get_tipo_display())","def __le__(self, other):\n return _generate_relational_expression(_le, self, other)","def E(self):\n return self._E","def E(self):\n return self._E","def __repr__(self):\n return self.__dado","def a_realization(self):\n if self.t==1:\n return self.kmonomial()\n else:\n return self.kHallLittlewoodP()","def one(self):\n return self.a_realization().one()","def __invert__(self):\r\n return 1 - self","def E_local(Walker):\n return Local_Kinetic(Walker)+potential(Walker)","def _getLilyAccidental(self):\n return \"\"","def joined(self):\n joined = self._joined\n if self._joined is None and self._joined_function is not None:\n joined = self._joined = self._joined_function()\n\n if joined is None:\n if self.path_is_string:\n joined = self._joined = self.path\n else:\n joined = self._joined = dot_joiner(self.path, self.path_type)\n return joined","def lsd(self):\n return self._lsd","def tag(self):\n \n tag = super(self.__class__, self).tag();\n tag = als.tag_join(tag, als.stra(self.strain));\n tag = als.tag_join(tag, als.stra(self.dtype));\n tag = als.tag_join(tag, 'w=%s' % als.stra(self.wid)); \n tag = als.tag_join(tag, 's=%s' % als.stra(self.stage));\n #tag = analysis.tag_join(tag, 'l=%s' % analysis.stra(self.label)); \n\n return tag;","def _merge_type(self):\n if self._allow_solar_only and self._allow_wind_only:\n return 'outer'\n elif self._allow_solar_only and not self._allow_wind_only:\n return 'left'\n elif not self._allow_solar_only and self._allow_wind_only:\n return 'right'\n return 'inner'","def slp(self):\n return self.elevcomp","def get_left(self):\n return self.__left","def modus_ponens(self, left_side):\n\t\tchecked_proposition(left_side)\n\t\tinterp = _match((A, impl, B), self)\n\t\tif interp[A] == left_side:\n\t\t\treturn self.__class__(interp[B])\n\t\traise LogicException()","def selfie(f):\n return f.__get__(f, type(f))","def _as_rhs(self):\n raise NotImplementedError","def equidistant(self):\n return self._equidistant","def playL(self,level=-1) :\n g = None\n if level >= 0 :\n level += 1\n for g in self.L() :\n if level>=0 :\n printIndent('%s' % (g,),level=level)\n print \n if g.playR(level) == None and not g.Tie() :\n return g\n for g in self.L() :\n if g.playR(level) == None and g.Tie() :\n return g\n return g","def __add__(self, right):\n # TODO: move over to any coercion model!\n if not isinstance(right, MatrixMorphism):\n R = self.base_ring()\n return self.parent()(self.matrix() + R(right))\n if not right.parent() == self.parent():\n right = self.parent()(right)\n M = self.matrix() + right.matrix()\n return self.domain().Hom(right.codomain())(M)","def to_adjective(self):\n return None","def right(self):\n\t\treturn self._right","def __le__(self, other):\n return self.master.abs2phy(pos=other)","def __le__(self, other):\n if self is other:\n return True\n if not isinstance(other, UniSet):\n other = self.fam.c_uniset(other)\n return self.fam.c_le(self, other)","def __or__(self, other):\n if is_FiniteStateMachine(other):\n return self.disjoint_union(other)\n else:\n raise TypeError(\"Can only add finite state machine\")","def L(self) -> float:\n return self._L","def express(self):\n raise NotImplementedError","def get_shortening_and_split_point(self):\n\n def get_shortening_type():\n \"\"\"Vrati Type of Lexical Shortening alebo None.\"\"\"\n if self.len_fn(self.sw) == self.get_length(): # self.len_fn je obycajne len\n return 'FSW'\n elif self.alignment.sw_idx == 0:\n return 'RS'\n elif self.alignment.sw_idx + len(self.alignment.generate()) == len(self.sw):\n return 'LS'\n\n shortening = get_shortening_type()\n\n if shortening not in ('RS', 'LS'):\n return shortening, None\n\n split_interface = {\n 'RS': (self.alignment.score - 1, self.alignment.score),\n 'LS': (self.alignment.sw_idx - 1, self.alignment.sw_idx)\n }[shortening]\n\n # ohodnotit rozhranie\n # ci je slabikove\n if split_interface in get_interfaces(self.sw_str):\n return shortening, 'syllable'\n\n types = [Phones.get_type(self.sw[idx]) for idx in split_interface]\n\n if types == ['c', 'v']:\n return shortening, 'onset-nucleus' # consonant - vowel\n elif types == ['v', 'c']:\n return shortening, 'nucleus-coda' # vowel - consonant\n else:\n return shortening, None","def __pout__(self):\n return self.__str__()","def get_right(self):\n return BinaryNode.or_none(self.right)","def downlinker(self):\n return self.__downlinker","def narration_self(self):\n pass","def __rmul__(self, other):\r\n if isinstance(other, tuple):\r\n return self.transform_point(other)\r\n if isinstance(other, LinearTransformation):\r\n return self.right_composition(other)\r\n else:\r\n raise NotImplementedError","def right(self, p):\n raise NotImplementedError('must be implemented by subclass')","def __str__(self):\n pos = self._pos + 1\n if len(self._refr) > len(self._alt):\n dellength = len(self._refr) - len(self._alt)\n return '{:s}:{:d}:{:d}D'.format(self._seqid, pos, dellength)\n else:\n insertion = self._alt[1:]\n return '{:s}:{:d}:I->{:s}'.format(self._seqid, pos, insertion)","def either(self):\n return self.v.index","def get_difficulte(self):\n return self.difficulte","def _successor(self):\n if self.right is None:\n # get first rightward ancestor\n m = self\n n = m.parent\n while n is not None and m is n.right:\n m = n\n n = n.parent\n else:\n # get leftmost of right child\n n = self.right\n while n.left is not None:\n n = n.left\n return n","def get_val_outer(cls, *args, **kwargs):\n return NotImplemented","def get_E(self):\r\n return self.Real.E, self.Ideal.E","def get_E(self):\r\n return self.Real.E, self.Ideal.E","def __le__(self, *args):\n return _ida_hexrays.ccase_t___le__(self, *args)","def get_aligner_edge(self):\n\n return self._aligner_edge","def right(self) -> Optional[\"ExpressionNode\"]:\n return self.__right","def normalize(self):\r\n return self"],"string":"[\n \"def L(self):\\n if not self.isVaild():\\n pass\\n return self.Lq() + self.r()\",\n \"def exterior_der(self):\\n from utilities import format_unop_txt, format_unop_latex\\n if self._exterior_derivative is None:\\n vmodule = self._vmodule # shortcut\\n rname = format_unop_txt('d', self._name)\\n rlname = format_unop_latex(r'\\\\mathrm{d}', self._latex_name)\\n resu = vmodule.alternating_form(self._tensor_rank+1, name=rname, \\n latex_name=rlname)\\n for dom, rst in self._restrictions.iteritems():\\n resu._restrictions[dom] = rst.exterior_der()\\n self._exterior_derivative = resu\\n return self._exterior_derivative\",\n \"def L(self):\\n return self._L\",\n \"def L(self):\\n return self.__L\",\n \"def L(self):\\n return self.__L\",\n \"def L(self):\\n return self.__L\",\n \"def L(self):\\n return self.__L\",\n \"def getL(self):\\r\\n return self.L\",\n \"def LDLT(self):\\n\\t\\tpass\",\n \"def lform(self):\\n a, c, d, b = self.to_ccw()\\n if b < c:\\n a += b\\n b -= b\\n c -= b\\n d += b\\n else:\\n a += c\\n b -= c\\n c -= c\\n d += c\\n return self.__class__.from_ccw(a, c, d, b)\",\n \"def dilemma(self, disjunction):\\n\\t\\tinterp1 = _match(((A, impl, B), conj, (C, impl, D)), self)\\n\\t\\tinterp2 = _match((A, disj, C), disjunction)\\n\\t\\tif interp1[A] == interp2[A] and interp1[C] == interp2[C]:\\n\\t\\t\\treturn self.__class__((interp1[B], disj, interp1[D]))\\n\\t\\telse:\\n\\t\\t\\traise LogicException()\",\n \"def Dang_l(self):\\n return self._Dang_l\",\n \"def either(self):\\n return self._v\",\n \"def dual(self):\\n letter = self.letter()\\n # the self-dual cases\\n if letter != 'BC' and letter[0] in ['B','C']:\\n if letter == 'BB': letter = 'CC'\\n elif letter == 'CC': letter = 'BB'\\n elif letter[0] == 'B': letter = 'C' + letter[1:]\\n elif letter[0] == 'C': letter = 'B' + letter[1:]\\n rank = self._rank\\n if self.is_affine():\\n rank -= 1\\n twist = self._twist\\n return QuiverMutationType(letter,rank,twist)\\n # the cases F and G have non-trivial duality in some cases\\n elif letter in ['F','G']:\\n if self.is_finite(): return self\\n elif self.is_affine():\\n rank = self._rank - 1\\n twist = - self._twist\\n elif self.is_elliptic():\\n twist = self._twist\\n rank = self._rank - 2\\n if letter == 'F':\\n if self._twist == [2,2]:\\n twist == [1,1]\\n if self._twist == [1,1]:\\n twist == [2,2]\\n if letter == 'G':\\n if self._twist == [3,3]:\\n twist = [1,1]\\n elif self._twist == [1,1]:\\n twist = [3,3]\\n else: rank = self._rank\\n return QuiverMutationType(letter,rank,twist)\\n else:\\n return self\",\n \"def ewald(self):\\n return self._ewald\",\n \"def getD(self):\\r\\n return self.D\",\n \"def _repr_(self):\\n return \\\"Lie algebra %s over %s\\\" % (self._classification,\\n self.base_ring())\",\n \"def right(self):\\n return self.__r\",\n \"def __le__(self, other):\\n if (self.master.__class__.__name__ == 'OneDimGrid') or (issubclass(self.master.__class__, OneDimGrid)):\\n return self._le_1d(other=other)\\n if (self.master.__class__.__name__ == 'Grid') or (issubclass(self.master.__class__, Grid)):\\n return self._le_2d(other=other)\",\n \"def get_E(self):\\r\\n return self.E\",\n \"def right(self):\\n return self.r\",\n \"def l_un_degenerate(self):\\n self.right = self.tmp\",\n \"def __arb__(self):\\n if self.tree.total < 1:\\n return None\\n if self.tree.total % 2 == 0:\\n return self.first()\\n else:\\n return self.last()\",\n \"def d(self):\\n pass\",\n \"def d(self):\\n pass\",\n \"def __aiter__(self):\\n return self\",\n \"def one_sided(self):\\n return self._one_sided\",\n \"def disagreement(self):\\n return 0.5*(np.dot(np.dot(np.transpose(self.x),self.L),self.x)).item(0)\",\n \"def __invert__(self):\\n return type(self)(self.parent(),\\n self._simplify(SR.one() / self._express))\\n # NB: self._express.__invert__() would return 1/self._express\\n # (cf. the code of __invert__ in src/sage/symbolic/expression.pyx)\\n # Here we prefer SR(1)/self._express\",\n \"def get_right(self):\\r\\n if getattr(self, '_right') is None:\\r\\n warnings.warn('Hmmm... I will use \\\"call\\\" right, since you did not provide any', UserWarning)\\r\\n self._right = 'call'\\r\\n\\r\\n return self._right\",\n \"def _der(self, x):\\n return self._evalOrDer(x, False, True)[0]\",\n \"def get_E(self):\\n return self.E\",\n \"def leverancier(self):\\n return self._leverancier.get_waarde()\",\n \"def l(self):\\n return self._l\",\n \"def lro(self) -> global___Snippet.Lro:\",\n \"def solveL(self,level=-1) :\\n for g in self.L() :\\n if level >= 0 :\\n printIndent('%s' % (g,),level=level)\\n print \\n if g.solveR(level=(level+1) if level>=0 else level) is None : \\n return g\\n return None\",\n \"def __invert__(self):\\n return self.obj\",\n \"def fodder(self):\\n return self._fodder\",\n \"def exterior_der(self):\\n from sage.calculus.functional import diff\\n from utilities import format_unop_txt, format_unop_latex\\n from sage.tensor.modules.comp import CompFullyAntiSym\\n from vectorframe import CoordFrame\\n if self._exterior_derivative is None:\\n # A new computation is necessary:\\n fmodule = self._fmodule # shortcut\\n rname = format_unop_txt('d', self._name)\\n rlname = format_unop_latex(r'\\\\mathrm{d}', self._latex_name)\\n self._exterior_derivative = DiffFormParal(fmodule, \\n self._tensor_rank+1, \\n name=rname, \\n latex_name=rlname)\\n # 1/ List of all coordinate frames in which the components of self\\n # are known\\n coord_frames = []\\n for frame in self._components:\\n if isinstance(frame, CoordFrame):\\n coord_frames.append(frame)\\n if coord_frames == []:\\n # A coordinate frame is searched, at the price of a change of\\n # frame, priveleging the frame of the domain's default chart\\n dom = self._domain\\n def_coordf = dom._def_chart._frame\\n for frame in self._components:\\n if (frame, def_coordf) in dom._frame_changes:\\n self.comp(def_coordf, from_basis=frame)\\n coord_frames = [def_coordf]\\n break\\n if coord_frames == []:\\n for chart in dom._atlas:\\n if chart != dom._def_chart: # the case def_chart is treated above\\n coordf = chart._frame\\n for frame in self._components:\\n if (frame, coordf) in dom._frame_changes:\\n self.comp(coordf, from_basis=frame)\\n coord_frames[coordf]\\n break\\n if coord_frames != []:\\n break \\n # 2/ The computation:\\n for frame in coord_frames:\\n chart = frame._chart\\n sc = self._components[frame]\\n dc = CompFullyAntiSym(fmodule._ring, frame, \\n self._tensor_rank+1, \\n start_index=fmodule._sindex,\\n output_formatter=fmodule._output_formatter)\\n for ind, val in sc._comp.iteritems():\\n for i in fmodule.irange():\\n ind_d = (i,) + ind\\n if len(ind_d) == len(set(ind_d)): \\n # all indices are different\\n dc[[ind_d]] += \\\\\\n val.function_chart(chart).diff(i).scalar_field()\\n self._exterior_derivative._components[frame] = dc\\n return self._exterior_derivative\",\n \"def get_right(self):\\n return self.__right\",\n \"def wedge(self, other):\\n from sage.tensor.modules.free_module_alt_form import FreeModuleAltForm\\n from sage.tensor.modules.format_utilities import is_atomic\\n if self._domain.is_subdomain(other._domain):\\n if not self._ambient_domain.is_subdomain(other._ambient_domain):\\n raise TypeError(\\\"Incompatible ambient domains for exterior \\\" + \\n \\\"product.\\\")\\n elif other._domain.is_subdomain(self._domain):\\n if not other._ambient_domain.is_subdomain(self._ambient_domain):\\n raise TypeError(\\\"Incompatible ambient domains for exterior \\\" + \\n \\\"product.\\\")\\n dom_resu = self._domain.intersection(other._domain)\\n ambient_dom_resu = self._ambient_domain.intersection(\\n other._ambient_domain)\\n self_r = self.restrict(dom_resu)\\n other_r = other.restrict(dom_resu)\\n if ambient_dom_resu.is_manifestly_parallelizable():\\n # call of the FreeModuleAltForm version:\\n return FreeModuleAltForm.wedge(self_r, other_r)\\n # otherwise, the result is created here:\\n if self._name is not None and other._name is not None:\\n sname = self._name\\n oname = other._name\\n if not is_atomic(sname):\\n sname = '(' + sname + ')'\\n if not is_atomic(oname):\\n oname = '(' + oname + ')'\\n resu_name = sname + '/\\\\\\\\' + oname\\n if self._latex_name is not None and other._latex_name is not None:\\n slname = self._latex_name\\n olname = other._latex_name\\n if not is_atomic(slname):\\n slname = '(' + slname + ')'\\n if not is_atomic(olname):\\n olname = '(' + olname + ')'\\n resu_latex_name = slname + r'\\\\wedge ' + olname\\n dest_map = self._vmodule._dest_map\\n dest_map_resu = dest_map.restrict(dom_resu, \\n subcodomain=ambient_dom_resu)\\n vmodule = dom_resu.vector_field_module(dest_map=dest_map_resu)\\n resu_degree = self._tensor_rank + other._tensor_rank\\n resu = vmodule.alternating_form(resu_degree, name=resu_name, \\n latex_name=resu_latex_name)\\n for dom in self_r._restrictions:\\n if dom in other_r._restrictions:\\n resu._restrictions[dom] = self_r._restrictions[dom].wedge(\\n other_r._restrictions[dom])\\n return resu\",\n \"def __or__(self, other):\\n raise NotImplementedError(\\\"failed monkey-patch: material stacker needs\\\"\\n \\\" to replace __or__ in Scatterer\\\")\",\n \"def getLEq(self):\\r\\n return self.lEq;\",\n \"def left(self):\\n return self.l\",\n \"def simplify(self):\\n return self\",\n \"def inner_endomorphism(self, multiplier):\\n return InnerEndomorphism(self.domain, multiplier)\",\n \"def __repr__(self):\\n\\n return f\\\"Legislator: {self.full_name} party: {self.party}\\\"\",\n \"def __call__(self):\\r\\n return self[-1]\",\n \"def DOR(self):\\n a, c, d, b = self.to_ccw()\\n ad, bc = a * d, b * c\\n return _div(ad, bc)\",\n \"def __call__(self):\\n return self._left() + self._right()\",\n \"def get_right(self):\\n return self.right\",\n \"def __invert__(self):\\r\\n if self.field.characteristic == 2:\\r\\n return runtime.invert(self)\\r\\n\\r\\n return super().__invert__()\",\n \"def pillar_e_room(self):\\r\\n return self.__pillar_e\",\n \"def related(self):\\n return self.__class__ != Rol and self or getattr(self, self.get_tipo_display())\",\n \"def __le__(self, other):\\n return _generate_relational_expression(_le, self, other)\",\n \"def E(self):\\n return self._E\",\n \"def E(self):\\n return self._E\",\n \"def __repr__(self):\\n return self.__dado\",\n \"def a_realization(self):\\n if self.t==1:\\n return self.kmonomial()\\n else:\\n return self.kHallLittlewoodP()\",\n \"def one(self):\\n return self.a_realization().one()\",\n \"def __invert__(self):\\r\\n return 1 - self\",\n \"def E_local(Walker):\\n return Local_Kinetic(Walker)+potential(Walker)\",\n \"def _getLilyAccidental(self):\\n return \\\"\\\"\",\n \"def joined(self):\\n joined = self._joined\\n if self._joined is None and self._joined_function is not None:\\n joined = self._joined = self._joined_function()\\n\\n if joined is None:\\n if self.path_is_string:\\n joined = self._joined = self.path\\n else:\\n joined = self._joined = dot_joiner(self.path, self.path_type)\\n return joined\",\n \"def lsd(self):\\n return self._lsd\",\n \"def tag(self):\\n \\n tag = super(self.__class__, self).tag();\\n tag = als.tag_join(tag, als.stra(self.strain));\\n tag = als.tag_join(tag, als.stra(self.dtype));\\n tag = als.tag_join(tag, 'w=%s' % als.stra(self.wid)); \\n tag = als.tag_join(tag, 's=%s' % als.stra(self.stage));\\n #tag = analysis.tag_join(tag, 'l=%s' % analysis.stra(self.label)); \\n\\n return tag;\",\n \"def _merge_type(self):\\n if self._allow_solar_only and self._allow_wind_only:\\n return 'outer'\\n elif self._allow_solar_only and not self._allow_wind_only:\\n return 'left'\\n elif not self._allow_solar_only and self._allow_wind_only:\\n return 'right'\\n return 'inner'\",\n \"def slp(self):\\n return self.elevcomp\",\n \"def get_left(self):\\n return self.__left\",\n \"def modus_ponens(self, left_side):\\n\\t\\tchecked_proposition(left_side)\\n\\t\\tinterp = _match((A, impl, B), self)\\n\\t\\tif interp[A] == left_side:\\n\\t\\t\\treturn self.__class__(interp[B])\\n\\t\\traise LogicException()\",\n \"def selfie(f):\\n return f.__get__(f, type(f))\",\n \"def _as_rhs(self):\\n raise NotImplementedError\",\n \"def equidistant(self):\\n return self._equidistant\",\n \"def playL(self,level=-1) :\\n g = None\\n if level >= 0 :\\n level += 1\\n for g in self.L() :\\n if level>=0 :\\n printIndent('%s' % (g,),level=level)\\n print \\n if g.playR(level) == None and not g.Tie() :\\n return g\\n for g in self.L() :\\n if g.playR(level) == None and g.Tie() :\\n return g\\n return g\",\n \"def __add__(self, right):\\n # TODO: move over to any coercion model!\\n if not isinstance(right, MatrixMorphism):\\n R = self.base_ring()\\n return self.parent()(self.matrix() + R(right))\\n if not right.parent() == self.parent():\\n right = self.parent()(right)\\n M = self.matrix() + right.matrix()\\n return self.domain().Hom(right.codomain())(M)\",\n \"def to_adjective(self):\\n return None\",\n \"def right(self):\\n\\t\\treturn self._right\",\n \"def __le__(self, other):\\n return self.master.abs2phy(pos=other)\",\n \"def __le__(self, other):\\n if self is other:\\n return True\\n if not isinstance(other, UniSet):\\n other = self.fam.c_uniset(other)\\n return self.fam.c_le(self, other)\",\n \"def __or__(self, other):\\n if is_FiniteStateMachine(other):\\n return self.disjoint_union(other)\\n else:\\n raise TypeError(\\\"Can only add finite state machine\\\")\",\n \"def L(self) -> float:\\n return self._L\",\n \"def express(self):\\n raise NotImplementedError\",\n \"def get_shortening_and_split_point(self):\\n\\n def get_shortening_type():\\n \\\"\\\"\\\"Vrati Type of Lexical Shortening alebo None.\\\"\\\"\\\"\\n if self.len_fn(self.sw) == self.get_length(): # self.len_fn je obycajne len\\n return 'FSW'\\n elif self.alignment.sw_idx == 0:\\n return 'RS'\\n elif self.alignment.sw_idx + len(self.alignment.generate()) == len(self.sw):\\n return 'LS'\\n\\n shortening = get_shortening_type()\\n\\n if shortening not in ('RS', 'LS'):\\n return shortening, None\\n\\n split_interface = {\\n 'RS': (self.alignment.score - 1, self.alignment.score),\\n 'LS': (self.alignment.sw_idx - 1, self.alignment.sw_idx)\\n }[shortening]\\n\\n # ohodnotit rozhranie\\n # ci je slabikove\\n if split_interface in get_interfaces(self.sw_str):\\n return shortening, 'syllable'\\n\\n types = [Phones.get_type(self.sw[idx]) for idx in split_interface]\\n\\n if types == ['c', 'v']:\\n return shortening, 'onset-nucleus' # consonant - vowel\\n elif types == ['v', 'c']:\\n return shortening, 'nucleus-coda' # vowel - consonant\\n else:\\n return shortening, None\",\n \"def __pout__(self):\\n return self.__str__()\",\n \"def get_right(self):\\n return BinaryNode.or_none(self.right)\",\n \"def downlinker(self):\\n return self.__downlinker\",\n \"def narration_self(self):\\n pass\",\n \"def __rmul__(self, other):\\r\\n if isinstance(other, tuple):\\r\\n return self.transform_point(other)\\r\\n if isinstance(other, LinearTransformation):\\r\\n return self.right_composition(other)\\r\\n else:\\r\\n raise NotImplementedError\",\n \"def right(self, p):\\n raise NotImplementedError('must be implemented by subclass')\",\n \"def __str__(self):\\n pos = self._pos + 1\\n if len(self._refr) > len(self._alt):\\n dellength = len(self._refr) - len(self._alt)\\n return '{:s}:{:d}:{:d}D'.format(self._seqid, pos, dellength)\\n else:\\n insertion = self._alt[1:]\\n return '{:s}:{:d}:I->{:s}'.format(self._seqid, pos, insertion)\",\n \"def either(self):\\n return self.v.index\",\n \"def get_difficulte(self):\\n return self.difficulte\",\n \"def _successor(self):\\n if self.right is None:\\n # get first rightward ancestor\\n m = self\\n n = m.parent\\n while n is not None and m is n.right:\\n m = n\\n n = n.parent\\n else:\\n # get leftmost of right child\\n n = self.right\\n while n.left is not None:\\n n = n.left\\n return n\",\n \"def get_val_outer(cls, *args, **kwargs):\\n return NotImplemented\",\n \"def get_E(self):\\r\\n return self.Real.E, self.Ideal.E\",\n \"def get_E(self):\\r\\n return self.Real.E, self.Ideal.E\",\n \"def __le__(self, *args):\\n return _ida_hexrays.ccase_t___le__(self, *args)\",\n \"def get_aligner_edge(self):\\n\\n return self._aligner_edge\",\n \"def right(self) -> Optional[\\\"ExpressionNode\\\"]:\\n return self.__right\",\n \"def normalize(self):\\r\\n return self\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.58051234","0.5680773","0.5520372","0.5517061","0.5517061","0.5517061","0.5517061","0.54927427","0.53145987","0.53131396","0.53023165","0.52391076","0.51286054","0.5116414","0.5094388","0.5080737","0.50450814","0.50200135","0.4995237","0.4990676","0.49585143","0.495757","0.49496916","0.4949266","0.4949266","0.49331263","0.49173918","0.4904543","0.48959923","0.48696694","0.4866807","0.484898","0.48487023","0.484504","0.48406687","0.48325294","0.48183498","0.48130405","0.4809159","0.47994956","0.4788736","0.47742686","0.47682858","0.47649083","0.47558814","0.47510013","0.4746676","0.4745134","0.47420457","0.47355372","0.4733411","0.4730426","0.4729896","0.4726305","0.47185355","0.4717856","0.4717856","0.47001714","0.4697558","0.46903816","0.46821204","0.46715882","0.46693975","0.46690753","0.4657426","0.46558982","0.46468335","0.46397272","0.46358076","0.4629119","0.46290645","0.4627924","0.46272817","0.46217936","0.4617234","0.4617076","0.4615747","0.46139702","0.46105495","0.46066588","0.46031442","0.46029815","0.45997778","0.45931652","0.45929706","0.45904127","0.45847973","0.45778957","0.4569975","0.4567407","0.456434","0.456424","0.4563033","0.45582944","0.45568603","0.45568603","0.45567557","0.4554619","0.4548449","0.45436767"],"string":"[\n \"0.58051234\",\n \"0.5680773\",\n \"0.5520372\",\n \"0.5517061\",\n \"0.5517061\",\n \"0.5517061\",\n \"0.5517061\",\n \"0.54927427\",\n \"0.53145987\",\n \"0.53131396\",\n \"0.53023165\",\n \"0.52391076\",\n \"0.51286054\",\n \"0.5116414\",\n \"0.5094388\",\n \"0.5080737\",\n \"0.50450814\",\n \"0.50200135\",\n \"0.4995237\",\n \"0.4990676\",\n \"0.49585143\",\n \"0.495757\",\n \"0.49496916\",\n \"0.4949266\",\n \"0.4949266\",\n \"0.49331263\",\n \"0.49173918\",\n \"0.4904543\",\n \"0.48959923\",\n \"0.48696694\",\n \"0.4866807\",\n \"0.484898\",\n \"0.48487023\",\n \"0.484504\",\n \"0.48406687\",\n \"0.48325294\",\n \"0.48183498\",\n \"0.48130405\",\n \"0.4809159\",\n \"0.47994956\",\n \"0.4788736\",\n \"0.47742686\",\n \"0.47682858\",\n \"0.47649083\",\n \"0.47558814\",\n \"0.47510013\",\n \"0.4746676\",\n \"0.4745134\",\n \"0.47420457\",\n \"0.47355372\",\n \"0.4733411\",\n \"0.4730426\",\n \"0.4729896\",\n \"0.4726305\",\n \"0.47185355\",\n \"0.4717856\",\n \"0.4717856\",\n \"0.47001714\",\n \"0.4697558\",\n \"0.46903816\",\n \"0.46821204\",\n \"0.46715882\",\n \"0.46693975\",\n \"0.46690753\",\n \"0.4657426\",\n \"0.46558982\",\n \"0.46468335\",\n \"0.46397272\",\n \"0.46358076\",\n \"0.4629119\",\n \"0.46290645\",\n \"0.4627924\",\n \"0.46272817\",\n \"0.46217936\",\n \"0.4617234\",\n \"0.4617076\",\n \"0.4615747\",\n \"0.46139702\",\n \"0.46105495\",\n \"0.46066588\",\n \"0.46031442\",\n \"0.46029815\",\n \"0.45997778\",\n \"0.45931652\",\n \"0.45929706\",\n \"0.45904127\",\n \"0.45847973\",\n \"0.45778957\",\n \"0.4569975\",\n \"0.4567407\",\n \"0.456434\",\n \"0.456424\",\n \"0.4563033\",\n \"0.45582944\",\n \"0.45568603\",\n \"0.45568603\",\n \"0.45567557\",\n \"0.4554619\",\n \"0.4548449\",\n \"0.45436767\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5174654"},"document_rank":{"kind":"string","value":"12"}}},{"rowIdx":398,"cells":{"query":{"kind":"string","value":"removes all Hydrogen atoms from instance"},"document":{"kind":"string","value":"def remove_hydrogens(self) -> None:\n for cid, c in self:\n for rid, r in c:\n for aid, a in r:\n if a.element == 'H':\n print('removing H at %s' % aid)\n r.remove_atom(a)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def delete(self):\n del self.shx.atoms[self.index]","def strip(self):\n types = [type(self.strip),\n type(self.values),\n type(self.__ne__),\n type(self.__class__)]\n\n for attr in dir(self):\n if not type(getattr(self, attr)) in types:\n if any(i in attr for i in self.keep) or attr[0:2] == '__':\n continue\n else:\n x = getattr(self, attr)\n del x\n for molecule in self.values():\n molecule.strip_molecule(self.keep)\n exit()","def cleanup(self):\n for residue in self.debumper.biomolecule.residues:\n if not isinstance(residue, aa.Amino):\n continue\n if residue.name == \"GLH\" or \"GLH\" in residue.patches:\n if residue.has_atom(\"HE1\") and residue.has_atom(\"HE2\"):\n residue.remove_atom(\"HE1\")\n elif residue.name == \"ASH\" or \"ASH\" in residue.patches:\n if residue.has_atom(\"HD1\") and residue.has_atom(\"HD2\"):\n residue.remove_atom(\"HD1\")","def removeDoubleUnbondedAtoms (self):\r\n atomsToRemove = [] # Stores index of atoms we will need to remove\r\n \r\n # Go through each mol\r\n for i in range(len(self.mol)):\r\n # Atom is disconnected if number of unbonded spikes is equal to the number of spikes in the atom\r\n numUnbondedSpikes = 0\r\n for j in range(len(self.mol[i].spikeArray)):\r\n if self.mol[i].spikeArray[j].bonded == False:\r\n # Spike not bonded so increment counter\r\n numUnbondedSpikes += 1\r\n # If atom disconnected then need to check to see if dangling nodes or tails are bonded\r\n if numUnbondedSpikes == len(self.mol[i].spikeArray):\r\n print (\"Atom: \" + str(self.mol[i].rbnNumber) + \" is being removed \\n\")\r\n anyBondedDanglingNodes = False\r\n for j in range(len(self.mol[i].spikeArray)):\r\n if self.isUnbondedAtomConnected(self.mol[i].spikeArray[j]) == True:\r\n anyBondedDanglingNodes = True\r\n # If atom has connected dangling nodes then need to convert atom to metaAtom, add metaAtom to metaMolecule and\r\n # remove atom from ring\r\n if anyBondedDanglingNodes == True:\r\n print (\"A new metaAtom is being created \\n\")\r\n newMetaAtom = self.convertUnbondedAtomToMetaAtom(self.mol[i])\r\n self.metaMolecule.addMetaAtom(newMetaAtom)\r\n atomsToRemove.append(i)\r\n \r\n # Now need to remove atoms\r\n print (\"Length of ring before removal: \" + str(len(self.mol)) + \"\\n\")\r\n for i in range(len(atomsToRemove)):\r\n self.mol.pop(atomsToRemove[i])\r\n print (\"Length of ring after removal: \" + str(len(self.mol)) + \"\\n\")\r\n # Finally need to update metaMolecule with new mol \r\n self.metaMolecule.updateListMols(self)","def _removeOcean(self):\r\n\t\tnodesToClean = [CONST.OCEANDISPSHADER, CONST.OCEANANIMSHADER, CONST.OCEAN_ANIM_PREVIEWPLANENAME]\r\n\t\tfor eachNode in nodesToClean:\r\n\t\t\ttry:\r\n\t\t\t\tcmds.delete(each)\r\n\t\t\texcept:\r\n\t\t\t\tpass","def remove_dummy(self) -> None:\n\n for i, atom in enumerate(self):\n if isinstance(atom, DummyAtom):\n del self[i]\n return","def remove(self, atom):\n try:\n self.hutch.remove_atom(atom)\n except:# AttributeError or ValueError:\n pass\n self.atoms.remove(atom)\n self.natoms -= 1\n self.atomtypes[atom.z] -= 1","def destroy(self):\n self.remove()\n for inst in reversed(self.insts[:]):\n uses = inst.uses()\n for tmp_inst in uses:\n if tmp_inst.op_name == 'OpPhi':\n IRError('Not implemented: remove from phi node') # XXX\n inst.destroy()\n self.module = None","def reset():\n for hist in (\"Epair_Etagm\", \"Etagm_Epair\", \"ttagm_pair\", \n \"Epair_Etagm_fit\", \"dEpair_Etagm_fit\"):\n h = ROOT.gROOT.FindObject(hist)\n if h:\n h.Delete()","def delX(self):\n del self.components[0]","def delX(self):\n del self.components[0]","def remove():","def _removeFX(self):\r\n\t\tnodesToClean = [CONST.FOAM_FLUID_SHAPENODE, CONST.WAKE_FLUID_SHAPENODE, 'fluids_hrc']\r\n\t\tfor eachNode in nodesToClean:\r\n\t\t\ttry:\r\n\t\t\t\tcmds.delete(each)\r\n\t\t\texcept:\r\n\t\t\t\tpass\r\n\r\n\t\tfor eachCache in cmds.ls(type = 'cacheFile'):\r\n\t\t\tcmds.delete(eachCache)","def remove(self):","def destroyGlobalNuclides():\n global instances\n global byName\n global byDBName\n global byLabel\n global byMcc2Id\n global byMcc3Id\n global byMcnpId\n global byAAAZZZSId\n\n instances = []\n byName.clear()\n byDBName.clear()\n byLabel.clear()\n byMcc2Id.clear()\n byMcc3Id.clear()\n byMcnpId.clear()\n byAAAZZZSId.clear()","def __call__(self, mol):\n return self.remove(mol)","def cleanup():\n for s in [missiles, explosions, bonus]:\n\n set_to_remove = set([])\n for m in s:\n if m.isDead:\n set_to_remove.add(m)\n\n s.difference_update(set_to_remove)","def remove_atom(atom_list, atom):\n del atom_list[atom.atom_number - 1]\n del atom\n return atom_list","def clear(self):\n\n\t\tself.atomid = []\n\t\tself.resi = []\n\t\tself.resn = []\n\t\tself.atom = []\n\t\tself.element = []\n\t\tself.chain = []\n\t\tself.type = []\n\t\tself.inverted = False\n\t\tself.atomlist = []\n\t\tself.keeplist = []\n\t\tself.macros = []\n\n\t\tself.invresi = False\n\t\tself.invresn = False\n\t\tself.invatom = False\n\t\tself.invelement = False\n\t\tself.invchain = False\n\t\tself.invtype = False\n\t\tself.invatomid = False","def cleanup(self):\n for key in list(self.__dict__.keys()):\n delattr(self, key)","def purgeHis(atoms):\n for a in atoms:\n if getAtype(a) == \"N\" or getAtype(a) == \"NA\":\n found = 0\n for c in atoms:\n if not c == a and dist(c,a) < COVALENT_BOND_DIST:\n found = 1\n break\n if not found:\n atoms.remove(a)\n return atoms\n if DEBUG: print \"Warning! Residue %s appears to be incomplete\" % (atoms[0][17:20]+atoms[0][22:26]+atoms[0][21])\n return False","def removeMySims(self):\n for sim in self.sims:\n try:\n sim.destroy()\n except:\n sim.removeNode()","def clean_copy(self):\n # this is a stub implementation\n #return Molecule(\"H2O\")\n m = self._gettokens()\n for t in self._gettokens():\n #if there is value errors or key errors, remove the invalid tokens\n if (t.isalpha() and t not in _atomic_mass) or (t not in \"()\" and not t.isalnum()):\n m.remove(t)\n str2 = \"\".join(m) \n return Molecule(str2)","def clean(self):\n for i in self.winfo_children():\n i.destroy()","def clear_quantities(shared):\n\n del_list = [i for i, fm in enumerate(shared.field_mappings)\n if fm.extra is not None]\n for index in reversed(del_list):\n del shared.field_mappings[index]\n\n shared.config.remove_section('extra')\n shared.config.add_section('extra')","def __del__(self):\n\n # Base class destructor is called ?? needed\n sim.Simulation.__del__(self)\n\n if self.verbose:\n print \"Cleaning derived simulation object LAMMPS1\"\n\n del self.pairCoeffDct\n del self.bondCoeffDct","def remove_atom(self, atom):\n assert atom.altloc == self\n del self[atom.alt_loc]\n atom.altloc = None","def delete():\n\n # Check the pipe setup.\n check_pipe_setup(sequence=True, j=True)\n\n # The interatomic data.\n for interatom in interatomic_loop():\n # The data.\n if hasattr(interatom, 'j_coupling'):\n del interatom.j_coupling\n\n # The error.\n if hasattr(interatom, 'j_coupling_err'):\n del interatom.j_coupling_err","def remove_atom(self, atom):\n assert isinstance(atom, Atom)\n assert atom.model_id == self.model_id \n self.chain_dict[atom.chain_id].remove_atom(atom)","def clear_cached_attributes(self):\n setattr(self, '_atoms', None)\n setattr(self, '_bonds', None)\n setattr(self, '_rings', None)\n setattr(self, '_ring_systems', None)","def destroy(self):\n del self.nodes\n self.nodes = {}","def remove_all(self):\n self._options.clear()\n self._programs.clear()","def noh(ls, dsets):\n data_set = build_set(ls[1], dsets)\n\n noh_set = set()\n pred = oechem.OEIsHydrogen()\n\n for idx in data_set:\n atom = system.GetAtom(oechem.OEHasAtomIdx(idx))\n if not pred(atom):\n noh_set.add(idx)\n\n return noh_set","def clear_protein(self):\n list.clear(self.occupied)","def remove_from_hand(self):\n pass","def clear(self):\n \n self.node_set.clear()\n self.prefix.clear()\n self.suffix.clear()\n self.num_node = 0\n self.edges = 0","def __del__(self):\r\n self.clearList()","def remove_atom(self, atom):\n assert atom.fragment == self\n\n if self.alt_loc_dict.has_key(atom.name):\n altloc = self.alt_loc_dict[atom.name]\n if altloc.has_key(atom.alt_loc):\n altloc.remove_atom(atom)\n if len(altloc) == 0:\n del self.alt_loc_dict[atom.name]\n self.atom_order_list.remove(altloc)\n if atom in self.atom_list:\n self.atom_list.remove(atom)\n del self.atom_dict[atom.name]\n else:\n self.atom_order_list.remove(atom)\n self.atom_list.remove(atom)\n del self.atom_dict[atom.name]\n\n atom.fragment = None","def del_cells(self):\t\r\n del self._cells","def removeAll(self):\n self.pDict.clear()","def clean(self):\n for nodeId in list(self.nodes.keys()):\n if not self.nodes[nodeId].safe:\n del self.nodes[nodeId]","def remove_from_model(self, destructive=False):\n self._model.remove_metabolites(self, destructive)","def remove_all(self):\n self.initial = None\n self.contour = None\n self.control_points = []","def del_lx(self):\r\n del self._lx","def remove(self):\n pass","def remove(self):\n pass","def remove(self):\n pass","def purge(self):\n keys = [k for (k, v) in self.get_range()]\n\n [self.remove(k) for k in keys]","def clear(self):\r\n\t\tself.free_objects[:] = []","def clear(self):\n for tag in self.meta.findall(CN('meta:user-defined')):\n self.meta.remove(tag)","def reset(self):\n self.mol.RHF(doPrint=False)\n self.dipole = []\n self.angmom = []\n self.Energy = []\n self.shape = []","def delDimension(self):\n self.components = []","def clear(self):\n self._nodes = { }\n self._arcs = set()","def clear(self):\n for vertex in self.vertices():\n del self[vertex]","def clear(self) -> None:\n self._moments = []","def clear_binstar(cli, owner):\n for channel in cli.list_channels(owner):\n cli.remove_channel(owner, channel)\n\n for package in cli.user_packages(owner):\n cli.remove_package(owner, package['name'])","def remove_eliminated_homes(self):\n filter_homes = []\n for home in self.homes:\n if not home.eliminated:\n filter_homes.append(home)\n self.homes = filter_homes","def unoccupied(self):\n self.is_occupied = 0\n for hex in self.fon:\n hex.remove_neighbor()\n hex.set_quality()","def delete_all_wells(self):\n self.wells = []","def _remove(self):\n pass","def unload(self):\n if self.material_background:\n self.parent.removeItem(self.material_background)\n self.material_background = None\n if self.mod_background:\n self.parent.removeItem(self.mod_background)\n self.mod_background = None\n if self.material_foreground:\n self.parent.removeItem(self.material_foreground)\n self.material_foreground = None\n if self.mod_foreground:\n self.parent.removeItem(self.mod_foreground)\n self.mod_foreground = None\n if self.liquid:\n self.parent.removeItem(self.liquid)\n self.liquid = None","def remove_all_spaces(self):\n self._register.clear()","def clear_extensions(self):\n self.extensions = set()","def delY(self):\n del self.components[1]","def delY(self):\n del self.components[1]","def convertUnbondedAtomToMetaAtom (self,atom):\r\n \r\n \r\n # Create a molecule consisting of just the atom\r\n mol = []\r\n mol.append(atom)\r\n # metaAtomNumber will be the length of the current metaMolecule\r\n metaAtomNumber = len(self.metaMolecule.metaAtoms)\r\n newMetaAtom = MetaAtom(metaAtomNumber,atom)\r\n # Next need to generate metaspikes we can do this by generating a metaspike object then finding the dangling nodes\r\n # and tails already created for this spike\r\n type1MetaSpike = metSpk.MetaSpike(1,0)\r\n type2MetaSpike = metSpk.MetaSpike(2,0)\r\n numDanglingNodes = 0\r\n numDanglingTails = 0\r\n danglingNodesToRemove = []\r\n danglingTailsToRemove = []\r\n indexType1Spike = 0\r\n indexType2Spike = 0\r\n for i in range(len(self.metaSpikes)):\r\n if self.metaSpikes[i].typeSpike == 1:\r\n indexType1Spike = i\r\n for j in range(len(self.metaSpikes[i].danglingNodeList)):\r\n print (\"The length of the dangling node list is: \" + str(len(self.metaSpikes[i].danglingNodeList)) + \"\\n\")\r\n print (\"The value of j is: \" + str(j) + \"\\n\")\r\n # See if dangling node belongs to atom being removed\r\n if self.metaSpikes[i].danglingNodeList[j].spike.RBN == atom:\r\n # If so then add to list of nodes being removed\r\n type1MetaSpike.addDanglingNode(self.metaSpikes[i].danglingNodeList[j])# Add to metaspike\r\n danglingNodesToRemove.append(j)\r\n numDanglingNodes += 1\r\n else:\r\n indexType2Spike = i\r\n for j in range(len(self.metaSpikes[i].danglingTailList)):\r\n print (\"The length of the dangling tail list is: \" + str(len(self.metaSpikes[i].danglingTailList)) + \"\\n\")\r\n print (\"The value of j is: \" + str(j) + \"\\n\")\r\n # See if dangling tail belongs to atom being removed\r\n if self.metaSpikes[i].danglingTailList[j].spike.RBN == atom:\r\n # If so then add to list of rails being removed\r\n type2MetaSpike.addTailDanglingBonds(self.metaSpikes[i].danglingTailList[j]) # Add to metaspike\r\n danglingTailsToRemove.append(j)\r\n numDanglingTails += 1 \r\n \r\n # If any dangling nodes have been found then the spike can be added to the metaAtom\r\n if numDanglingNodes > 0: \r\n newMetaAtom.addMetaSpike(type1MetaSpike)\r\n # Next need to remove danglingNodes no longer located in this metaAtom\r\n danglingNodesToRemove.sort(reverse = True) # Sort so popping values doesnt affect other indexes\r\n for i in range (len(danglingNodesToRemove)):\r\n self.metaSpikes[indexType1Spike].danglingNodeList.pop(danglingNodesToRemove[i])\r\n \r\n # If any dangling tails have been found then the spike can be added to the metaAtom\r\n if numDanglingTails > 0: \r\n newMetaAtom.addMetaSpike(type2MetaSpike)\r\n # Next need to remove danglingtails no longer located in this metaAtom\r\n danglingTailsToRemove.sort(reverse = True) # Sort so popping values doesnt affect other indexes\r\n for i in range (len(danglingTailsToRemove)):\r\n self.metaSpikes[indexType2Spike].danglingNodeList.pop(danglingTailsToRemove[i])\r\n\r\n \r\n \r\n \r\n # We repeated this process for dangling tails\r\n \r\n type2MetaSpike = metSpk.MetaSpike(2,1)\r\n \r\n numDanglingTails = 0\r\n for i in range(len(self.metaSpikes)):\r\n if self.metaSpikes[i].typeSpike == 2:\r\n for j in range(len(self.metaSpikes[i].danglingTailList)):\r\n if self.metaSpikes[i].danglingTailList[j].spike.RBN == atom:\r\n type2MetaSpike.addTailDanglingBonds(self.metaSpikes[i].danglingTailList[j])\r\n danglingTailsToRemove.append(j)\r\n numDanglingTails += 1\r\n # If any dangling nodes have been found then the spike can be added to the metaAtom\r\n if numDanglingTails > 0: \r\n newMetaAtom.addMetaSpike(type2MetaSpike)\r\n # Next need to remove danglingNodes no longer located in this metaAtom\r\n danglingTailsToRemove.sort(reverse = True) # Sort so popping values doesnt affect other indexes\r\n for i in range (len(danglingTailsToRemove)):\r\n self.metaSpikes[i].danglingTailList.pop(danglingTailsToRemove[i])\r\n \r\n return newMetaAtom","def clear(self):\r\n ElementSet.clear(self)\r\n self.update()","def full_clear(self):\n self.clear()\n self.class_hooks.clear()","def remove_abs_vars(self):\n self.m.remove(self.bp_abs)\n self.m.remove(self.bn_abs)\n self.m.remove(self.gp_abs)\n self.m.remove(self.gn_abs)\n self.m.remove(self.beta_p)\n self.m.remove(self.beta_n)\n self.m.remove(self.gamma_p)\n self.m.remove(self.gamma_n)","def clean(self):\n\t\tfor v in self:\n\t\t\tv.reset_distance()\n\t\t\tv.reset_predecessor()\n\t\t\tv.reset_visited()","def CleanUp(self):\n for Ind in self.IndList():\n if amax(abs(self[Ind]))<1e-10:\n del self[Ind]","def clearAllElementMetaIdList(self):\n return _libsbml.Model_clearAllElementMetaIdList(self)","def removeAtomStrainDuplicates(self, tol_mag = 7, verbose = 1):\n\n keep = self.getAtomStrainDuplicates(tol_mag = tol_mag, verbose = verbose - 1)\n\n self.deleteInterfaces(keep = keep, verbose = verbose)","def remove_stems(graph = None):\n\tfor x,y in basepairs(graph = graph):\n\t\tgraph.remove_node(x)\n\t\tgraph.remove_node(y)","def delete_all(self):\n for tag in self._segments['APP1'].get_tag_list():\n try:\n self.__delattr__(tag)\n except AttributeError:\n warnings.warn(\"could not delete tag \" + tag, RuntimeWarning)","def remove(self, egg):","def remove(self) -> None:\n self.map.cordons.remove(self)","def clear(self) -> None:\n # Delete these so the .by_class/name values are cleared.\n self['classname'] = 'info_null'\n del self['targetname']\n self._keys.clear()\n # Clear $fixup as well.\n self._fixup = None","def clear(self) -> None:\n logger.info(\"destroying all registered mutants\")\n try:\n uuids = list(self)\n for uuid in uuids:\n del self[uuid]\n except Exception:\n logger.exception(\"failed to destroy all registered mutants\")\n raise\n logger.info(\"destroyed all registered mutants\")","def _RemoveFromCloneList(self, clone, attrNamesToClone):\n attrNamesToClone = super(EquationUnit, self)._RemoveFromCloneList(clone, attrNamesToClone)\n \n dontClone = [\"_Funcs\", \"_FuncsDefs\"]\n \n for name in dontClone:\n if name in attrNamesToClone:\n attrNamesToClone.remove(name)\n \n return attrNamesToClone","def reset(self):\n self.entities = set()\n self.frozen = False","def removeDegenerate(self):\n return self[~self.testDegenerate()]","def clear_dummy_obj(self):\n for d in self.dummies:\n self.map.remove_node(d)\n\n self.dummies = []","def prune(self): # HashMap.prune\n for hashval, list in self.contentHash.iteritems():\n newlist=[]\n for entry in list:\n if not entry.deleted:\n newlist.append(entry)\n self.contentHash[hashval]=newlist","def clear(self):\n self.chromosome_list = []","def clear(self):","def clear(self):","def clear(self):","def clear(self):","def clear(self):","def clear(self):","def clear(self):","def unload(self) -> None:\n for attr in self._attrs:\n setattr(self, attr, None)","def del_lz(self):\r\n del self._lz","def delete_lattice(): \n # Delete the existing lattice\n for o in bpy.data.objects:\n if o.type == 'LATTICE':\n # Delete the existing lattice\n object_to_delete = bpy.data.objects[\"Lattice\"]\n bpy.data.objects.remove(object_to_delete, do_unlink=True)","def remove_tactic(self):\n tactic_removed = input(\"Enter a tactic to be removed: \")\n self.proof.tactics.remove(tactic_removed)\n for gene in self.population:\n gene.chromosome = [e for e in gene.chromosome if e != tactic_removed]","def clear_structure(self):\n self.structure = []\n return","def cleanup(self):\n for attribute in self._all_db_field_names:\n delattr(self, attribute)","def parse_hydrogen(self, res, topo):\n name = self.map[res].name\n opttype = self.map[res].opttype\n optangle = self.map[res].optangle\n map_ = self.map[res].map\n mydef = HydrogenDefinition(name, opttype, optangle, map_)\n patch_map = []\n atoms = []\n refatoms = []\n conformernames = []\n refmap = {}\n titrationstatemap = {}\n tautomermap = {}\n conformermap = {}\n atommap = {}\n ntrmap = {}\n hmap = {}\n nonhmap = {}\n # reference map from TOPOLOGY.xml\n for res_ in topo.residues:\n refmap[res_.name] = res_.reference\n for atom in refmap[res_.name].atoms:\n atommap[res_.name, atom.name] = atom\n for titrationstate in res_.titration_states:\n titrationstatemap[titrationstate.name] = titrationstate\n for tautomer in titrationstate.tautomers:\n tautomermap[tautomer.name] = tautomer\n for conformer in tautomer.conformers:\n conformermap[conformer.name] = conformer\n if name == \"CYS\":\n _ = refmap[\"CYS\"]\n atoms = [\"HG\"]\n refatoms = [\"SG\", \"CB\"]\n elif name == \"HIS\":\n _ = refmap[\"HIS\"]\n atoms = [\"HD1\", \"HE2\"]\n for atom in atoms:\n refatoms = [\"ND1\", \"CG\", \"CE1\"]\n elif name == \"LYS\":\n _ = self.debumper.biomolecule.reference_map[name]\n patch_map = self.debumper.biomolecule.patch_map[\"LYN\"]\n atoms = patch_map.remove\n refatoms = [\"HZ1\", \"HZ2\", \"NZ\"]\n elif name == \"TYR\":\n _ = self.debumper.biomolecule.reference_map[name]\n patch_map = self.debumper.biomolecule.patch_map[\"TYM\"]\n atoms = patch_map.remove\n refatoms = [\"OH\", \"CZ\", \"CE2\"]\n elif name == \"WAT\":\n _ = self.debumper.biomolecule.reference_map[name]\n patch_map = self.debumper.biomolecule.patch_map[\"HOH\"]\n atoms = [\"H1\", \"H2\"]\n refatoms = None\n elif name == \"NTR\":\n ntrmap = {} # map for N-TERM\n for tautomer in titrationstatemap[\"NTER\"].tautomers:\n for conformer in tautomermap[tautomer.name].conformers:\n for conformeradds in conformermap[\n conformer.name\n ].conformer_adds:\n for atom in conformeradds.atoms:\n ntrmap[atom.name] = atom\n atoms = [\"H3\", \"H2\"]\n refatoms = [\"CA\", \"H\", \"N\"]\n elif name == \"CTR\":\n hmap = {} # map for h atoms\n nonhmap = {} # map for refatoms\n conformernames = []\n for tautomer in titrationstatemap[\"CTER\"].tautomers:\n for conformer in tautomermap[tautomer.name].conformers:\n for conformeradds in conformermap[\n conformer.name\n ].conformer_adds:\n for atom in conformeradds.atoms:\n nonhmap[atom.name] = atom\n for tautomer in titrationstatemap[\"CTER0\"].tautomers:\n for conformer in tautomermap[tautomer.name].conformers:\n conformernames.append(conformer.name)\n for conformeradds in conformermap[\n conformer.name\n ].conformer_adds:\n for atom in conformeradds.atoms:\n hmap[conformer.name, atom.name] = atom\n atoms = [\"HO\"]\n refatoms = [\"O\", \"C\", \"OXT\"]\n elif name in [\"SER\", \"GLN\", \"THR\", \"ARG\", \"ASN\"]:\n _ = refmap[name]\n if name == \"SER\":\n atoms = [\"HG\"]\n refatoms = [\"OG\", \"CB\"]\n elif name == \"GLN\":\n atoms = [\"HE21\"]\n refatoms = [\"NE2\"]\n elif name == \"THR\":\n atoms = [\"HG1\"]\n refatoms = [\"OG1\", \"CB\"]\n elif name == \"ARG\":\n atoms = [\"HH11\", \"HH12\", \"HH21\", \"HH22\", \"HE\"]\n for atom in atoms:\n refatoms = [\"NH1\", \"NH2\", \"CZ\"]\n elif name == \"ASN\":\n atoms = [\"HD21\"]\n refatoms = [\"ND2\"]\n elif name == \"ASH\":\n hmap = {} # map for h atoms\n nonhmap = {} # map for refatoms\n conformernames = []\n _ = refmap[\"ASP\"]\n for tautomer in titrationstatemap[\"ASH\"].tautomers:\n for conformer in tautomermap[tautomer.name].conformers:\n for conformeradds in conformermap[\n conformer.name\n ].conformer_adds:\n for atom in conformeradds.atoms:\n hmap[conformer.name, atom.name] = atom\n conformernames.append(conformer.name)\n atoms = [\"HD1\", \"HD2\"]\n refatoms = [\"OD1\", \"CG\", \"OD2\"]\n elif name == \"GLH\":\n hmap = {} # map for h atoms\n nonhmap = {} # map for refatoms\n conformernames = []\n _ = refmap[\"GLU\"]\n for tautomer in titrationstatemap[\"GLH\"].tautomers:\n for conformer in tautomermap[tautomer.name].conformers:\n for conformeradds in conformermap[\n conformer.name\n ].conformer_adds:\n for atom in conformeradds.atoms:\n hmap[conformer.name, atom.name] = atom\n conformernames.append(conformer.name)\n atoms = [\"HE1\", \"HE2\"]\n refatoms = [\"OE1\", \"CD\", \"OE2\"]\n else:\n patch_map = self.debumper.biomolecule.patch_map[name]\n atoms = list(patch_map.map.keys())\n atoms.sort()\n if name in [\"NTR\"]:\n bondlength = 1.0\n for atom in atoms:\n hname = atom\n x = ntrmap[hname].x\n y = ntrmap[hname].y\n z = ntrmap[hname].z\n bondatom = ntrmap[hname].bonds[0]\n myconf = HydrogenConformation(hname, bondatom, bondlength)\n atom = defns.DefinitionAtom(hname, x, y, z)\n myconf.add_atom(atom)\n\n # TODO - lots of arbitrary undefined numbers in this section\n for atom_ in refatoms:\n if atom_ == \"N\":\n natom = defns.DefinitionAtom(atom_, 1.201, 0.847, 0.0)\n myconf.add_atom(natom)\n elif atom_ == \"CA\":\n caatom = defns.DefinitionAtom(atom_, 0.0, 0.0, 0.0)\n myconf.add_atom(caatom)\n elif atom_ == \"H\":\n caatom = defns.DefinitionAtom(\n atom_, 1.201, 1.847, 0.000\n )\n myconf.add_atom(caatom)\n mydef.add_conf(myconf)\n elif name in [\"CTR\"]:\n bondlength = 1.0\n for conformer in conformernames:\n for atom in atoms:\n hname = atom\n x = hmap[conformer, hname].x\n y = hmap[conformer, hname].y\n z = hmap[conformer, hname].z\n bondatom = hmap[conformer, hname].bonds[0]\n myconf = HydrogenConformation(hname, bondatom, bondlength)\n atom = defns.DefinitionAtom(hname, x, y, z)\n myconf.add_atom(atom)\n\n # TODO - the following code is almost nonsensical\n for atom_ in refatoms:\n if atom_ == \"C\":\n catom = defns.DefinitionAtom(\n atom_, -1.250, 0.881, 0.000\n )\n myconf.add_atom(catom)\n else:\n atomname = atom_\n x = nonhmap[atom_].x\n y = nonhmap[atom_].y\n z = nonhmap[atom_].z\n atom2 = defns.DefinitionAtom(atomname, x, y, z)\n myconf.add_atom(atom2)\n mydef.add_conf(myconf)\n\n elif name in [\"ASH\", \"GLH\"]:\n for conformer in conformernames:\n for atom in atoms:\n hname = atom\n if (\"1\" in conformer and \"1\" in atom) or (\n \"2\" in conformer and \"2\" in atom\n ):\n x = hmap[conformer, hname].x\n y = hmap[conformer, hname].y\n z = hmap[conformer, hname].z\n bondatom = hmap[conformer, hname].bonds[0]\n bondlength = 1.0\n myconf = HydrogenConformation(\n hname, bondatom, bondlength\n )\n atom = defns.DefinitionAtom(hname, x, y, z)\n myconf.add_atom(atom)\n\n for atom_ in refatoms:\n atomname = atom_\n refresname = \"\"\n if name == \"ASH\":\n refresname = \"ASP\"\n elif name == \"GLH\":\n refresname = \"GLU\"\n x = atommap[refresname, atom_].x\n y = atommap[refresname, atom_].y\n z = atommap[refresname, atom_].z\n atom2 = defns.DefinitionAtom(atomname, x, y, z)\n myconf.add_atom(atom2)\n mydef.add_conf(myconf)\n elif name not in [\"WAT\"]:\n bondlength = 1.0\n for atom in atoms:\n hname = atom\n x = atommap[name, hname].x\n y = atommap[name, hname].y\n z = atommap[name, hname].z\n bondatom = atommap[name, hname].bonds[0]\n myconf = HydrogenConformation(hname, bondatom, bondlength)\n atom = defns.DefinitionAtom(hname, x, y, z)\n myconf.add_atom(atom)\n if refatoms is not None:\n if name == \"HIS\" and atom.name == \"HE2\":\n refatoms = [\"NE2\", \"CE1\", \"CD2\"]\n if name == \"ARG\" and atom.name == \"HE\":\n refatoms = [\"NE\", \"CZ\", \"NH1\"]\n # FIXME: 2020/07/06 intendo - the \"atom\" is reused in\n # the outer for loop and ambiguous\n for atom in refatoms:\n atomname = atom\n x = atommap[name, atomname].x\n y = atommap[name, atomname].y\n z = atommap[name, atomname].z\n atom = defns.DefinitionAtom(atomname, x, y, z)\n myconf.add_atom(atom)\n mydef.add_conf(myconf)\n return mydef","def destroy(self):\n for inst in self.module.global_insts[:]:\n if (inst.op_name in spirv.DECORATION_INSTRUCTIONS or\n inst.op_name in spirv.DEBUG_INSTRUCTIONS):\n if self.result_id in inst.operands:\n inst.destroy()\n if self.basic_block is None:\n if self not in self.module.global_insts:\n raise IRError('Instruction is not in basic block or module')\n self.module.global_insts.remove(self)\n return\n self.basic_block.insts.remove(self)\n if self.result_id is not None:\n del self.module.id_to_inst[self.result_id]\n self.basic_block = None\n self.op_name = None\n self.result_id = None\n self.type_id = None\n self.operands = None"],"string":"[\n \"def delete(self):\\n del self.shx.atoms[self.index]\",\n \"def strip(self):\\n types = [type(self.strip),\\n type(self.values),\\n type(self.__ne__),\\n type(self.__class__)]\\n\\n for attr in dir(self):\\n if not type(getattr(self, attr)) in types:\\n if any(i in attr for i in self.keep) or attr[0:2] == '__':\\n continue\\n else:\\n x = getattr(self, attr)\\n del x\\n for molecule in self.values():\\n molecule.strip_molecule(self.keep)\\n exit()\",\n \"def cleanup(self):\\n for residue in self.debumper.biomolecule.residues:\\n if not isinstance(residue, aa.Amino):\\n continue\\n if residue.name == \\\"GLH\\\" or \\\"GLH\\\" in residue.patches:\\n if residue.has_atom(\\\"HE1\\\") and residue.has_atom(\\\"HE2\\\"):\\n residue.remove_atom(\\\"HE1\\\")\\n elif residue.name == \\\"ASH\\\" or \\\"ASH\\\" in residue.patches:\\n if residue.has_atom(\\\"HD1\\\") and residue.has_atom(\\\"HD2\\\"):\\n residue.remove_atom(\\\"HD1\\\")\",\n \"def removeDoubleUnbondedAtoms (self):\\r\\n atomsToRemove = [] # Stores index of atoms we will need to remove\\r\\n \\r\\n # Go through each mol\\r\\n for i in range(len(self.mol)):\\r\\n # Atom is disconnected if number of unbonded spikes is equal to the number of spikes in the atom\\r\\n numUnbondedSpikes = 0\\r\\n for j in range(len(self.mol[i].spikeArray)):\\r\\n if self.mol[i].spikeArray[j].bonded == False:\\r\\n # Spike not bonded so increment counter\\r\\n numUnbondedSpikes += 1\\r\\n # If atom disconnected then need to check to see if dangling nodes or tails are bonded\\r\\n if numUnbondedSpikes == len(self.mol[i].spikeArray):\\r\\n print (\\\"Atom: \\\" + str(self.mol[i].rbnNumber) + \\\" is being removed \\\\n\\\")\\r\\n anyBondedDanglingNodes = False\\r\\n for j in range(len(self.mol[i].spikeArray)):\\r\\n if self.isUnbondedAtomConnected(self.mol[i].spikeArray[j]) == True:\\r\\n anyBondedDanglingNodes = True\\r\\n # If atom has connected dangling nodes then need to convert atom to metaAtom, add metaAtom to metaMolecule and\\r\\n # remove atom from ring\\r\\n if anyBondedDanglingNodes == True:\\r\\n print (\\\"A new metaAtom is being created \\\\n\\\")\\r\\n newMetaAtom = self.convertUnbondedAtomToMetaAtom(self.mol[i])\\r\\n self.metaMolecule.addMetaAtom(newMetaAtom)\\r\\n atomsToRemove.append(i)\\r\\n \\r\\n # Now need to remove atoms\\r\\n print (\\\"Length of ring before removal: \\\" + str(len(self.mol)) + \\\"\\\\n\\\")\\r\\n for i in range(len(atomsToRemove)):\\r\\n self.mol.pop(atomsToRemove[i])\\r\\n print (\\\"Length of ring after removal: \\\" + str(len(self.mol)) + \\\"\\\\n\\\")\\r\\n # Finally need to update metaMolecule with new mol \\r\\n self.metaMolecule.updateListMols(self)\",\n \"def _removeOcean(self):\\r\\n\\t\\tnodesToClean = [CONST.OCEANDISPSHADER, CONST.OCEANANIMSHADER, CONST.OCEAN_ANIM_PREVIEWPLANENAME]\\r\\n\\t\\tfor eachNode in nodesToClean:\\r\\n\\t\\t\\ttry:\\r\\n\\t\\t\\t\\tcmds.delete(each)\\r\\n\\t\\t\\texcept:\\r\\n\\t\\t\\t\\tpass\",\n \"def remove_dummy(self) -> None:\\n\\n for i, atom in enumerate(self):\\n if isinstance(atom, DummyAtom):\\n del self[i]\\n return\",\n \"def remove(self, atom):\\n try:\\n self.hutch.remove_atom(atom)\\n except:# AttributeError or ValueError:\\n pass\\n self.atoms.remove(atom)\\n self.natoms -= 1\\n self.atomtypes[atom.z] -= 1\",\n \"def destroy(self):\\n self.remove()\\n for inst in reversed(self.insts[:]):\\n uses = inst.uses()\\n for tmp_inst in uses:\\n if tmp_inst.op_name == 'OpPhi':\\n IRError('Not implemented: remove from phi node') # XXX\\n inst.destroy()\\n self.module = None\",\n \"def reset():\\n for hist in (\\\"Epair_Etagm\\\", \\\"Etagm_Epair\\\", \\\"ttagm_pair\\\", \\n \\\"Epair_Etagm_fit\\\", \\\"dEpair_Etagm_fit\\\"):\\n h = ROOT.gROOT.FindObject(hist)\\n if h:\\n h.Delete()\",\n \"def delX(self):\\n del self.components[0]\",\n \"def delX(self):\\n del self.components[0]\",\n \"def remove():\",\n \"def _removeFX(self):\\r\\n\\t\\tnodesToClean = [CONST.FOAM_FLUID_SHAPENODE, CONST.WAKE_FLUID_SHAPENODE, 'fluids_hrc']\\r\\n\\t\\tfor eachNode in nodesToClean:\\r\\n\\t\\t\\ttry:\\r\\n\\t\\t\\t\\tcmds.delete(each)\\r\\n\\t\\t\\texcept:\\r\\n\\t\\t\\t\\tpass\\r\\n\\r\\n\\t\\tfor eachCache in cmds.ls(type = 'cacheFile'):\\r\\n\\t\\t\\tcmds.delete(eachCache)\",\n \"def remove(self):\",\n \"def destroyGlobalNuclides():\\n global instances\\n global byName\\n global byDBName\\n global byLabel\\n global byMcc2Id\\n global byMcc3Id\\n global byMcnpId\\n global byAAAZZZSId\\n\\n instances = []\\n byName.clear()\\n byDBName.clear()\\n byLabel.clear()\\n byMcc2Id.clear()\\n byMcc3Id.clear()\\n byMcnpId.clear()\\n byAAAZZZSId.clear()\",\n \"def __call__(self, mol):\\n return self.remove(mol)\",\n \"def cleanup():\\n for s in [missiles, explosions, bonus]:\\n\\n set_to_remove = set([])\\n for m in s:\\n if m.isDead:\\n set_to_remove.add(m)\\n\\n s.difference_update(set_to_remove)\",\n \"def remove_atom(atom_list, atom):\\n del atom_list[atom.atom_number - 1]\\n del atom\\n return atom_list\",\n \"def clear(self):\\n\\n\\t\\tself.atomid = []\\n\\t\\tself.resi = []\\n\\t\\tself.resn = []\\n\\t\\tself.atom = []\\n\\t\\tself.element = []\\n\\t\\tself.chain = []\\n\\t\\tself.type = []\\n\\t\\tself.inverted = False\\n\\t\\tself.atomlist = []\\n\\t\\tself.keeplist = []\\n\\t\\tself.macros = []\\n\\n\\t\\tself.invresi = False\\n\\t\\tself.invresn = False\\n\\t\\tself.invatom = False\\n\\t\\tself.invelement = False\\n\\t\\tself.invchain = False\\n\\t\\tself.invtype = False\\n\\t\\tself.invatomid = False\",\n \"def cleanup(self):\\n for key in list(self.__dict__.keys()):\\n delattr(self, key)\",\n \"def purgeHis(atoms):\\n for a in atoms:\\n if getAtype(a) == \\\"N\\\" or getAtype(a) == \\\"NA\\\":\\n found = 0\\n for c in atoms:\\n if not c == a and dist(c,a) < COVALENT_BOND_DIST:\\n found = 1\\n break\\n if not found:\\n atoms.remove(a)\\n return atoms\\n if DEBUG: print \\\"Warning! Residue %s appears to be incomplete\\\" % (atoms[0][17:20]+atoms[0][22:26]+atoms[0][21])\\n return False\",\n \"def removeMySims(self):\\n for sim in self.sims:\\n try:\\n sim.destroy()\\n except:\\n sim.removeNode()\",\n \"def clean_copy(self):\\n # this is a stub implementation\\n #return Molecule(\\\"H2O\\\")\\n m = self._gettokens()\\n for t in self._gettokens():\\n #if there is value errors or key errors, remove the invalid tokens\\n if (t.isalpha() and t not in _atomic_mass) or (t not in \\\"()\\\" and not t.isalnum()):\\n m.remove(t)\\n str2 = \\\"\\\".join(m) \\n return Molecule(str2)\",\n \"def clean(self):\\n for i in self.winfo_children():\\n i.destroy()\",\n \"def clear_quantities(shared):\\n\\n del_list = [i for i, fm in enumerate(shared.field_mappings)\\n if fm.extra is not None]\\n for index in reversed(del_list):\\n del shared.field_mappings[index]\\n\\n shared.config.remove_section('extra')\\n shared.config.add_section('extra')\",\n \"def __del__(self):\\n\\n # Base class destructor is called ?? needed\\n sim.Simulation.__del__(self)\\n\\n if self.verbose:\\n print \\\"Cleaning derived simulation object LAMMPS1\\\"\\n\\n del self.pairCoeffDct\\n del self.bondCoeffDct\",\n \"def remove_atom(self, atom):\\n assert atom.altloc == self\\n del self[atom.alt_loc]\\n atom.altloc = None\",\n \"def delete():\\n\\n # Check the pipe setup.\\n check_pipe_setup(sequence=True, j=True)\\n\\n # The interatomic data.\\n for interatom in interatomic_loop():\\n # The data.\\n if hasattr(interatom, 'j_coupling'):\\n del interatom.j_coupling\\n\\n # The error.\\n if hasattr(interatom, 'j_coupling_err'):\\n del interatom.j_coupling_err\",\n \"def remove_atom(self, atom):\\n assert isinstance(atom, Atom)\\n assert atom.model_id == self.model_id \\n self.chain_dict[atom.chain_id].remove_atom(atom)\",\n \"def clear_cached_attributes(self):\\n setattr(self, '_atoms', None)\\n setattr(self, '_bonds', None)\\n setattr(self, '_rings', None)\\n setattr(self, '_ring_systems', None)\",\n \"def destroy(self):\\n del self.nodes\\n self.nodes = {}\",\n \"def remove_all(self):\\n self._options.clear()\\n self._programs.clear()\",\n \"def noh(ls, dsets):\\n data_set = build_set(ls[1], dsets)\\n\\n noh_set = set()\\n pred = oechem.OEIsHydrogen()\\n\\n for idx in data_set:\\n atom = system.GetAtom(oechem.OEHasAtomIdx(idx))\\n if not pred(atom):\\n noh_set.add(idx)\\n\\n return noh_set\",\n \"def clear_protein(self):\\n list.clear(self.occupied)\",\n \"def remove_from_hand(self):\\n pass\",\n \"def clear(self):\\n \\n self.node_set.clear()\\n self.prefix.clear()\\n self.suffix.clear()\\n self.num_node = 0\\n self.edges = 0\",\n \"def __del__(self):\\r\\n self.clearList()\",\n \"def remove_atom(self, atom):\\n assert atom.fragment == self\\n\\n if self.alt_loc_dict.has_key(atom.name):\\n altloc = self.alt_loc_dict[atom.name]\\n if altloc.has_key(atom.alt_loc):\\n altloc.remove_atom(atom)\\n if len(altloc) == 0:\\n del self.alt_loc_dict[atom.name]\\n self.atom_order_list.remove(altloc)\\n if atom in self.atom_list:\\n self.atom_list.remove(atom)\\n del self.atom_dict[atom.name]\\n else:\\n self.atom_order_list.remove(atom)\\n self.atom_list.remove(atom)\\n del self.atom_dict[atom.name]\\n\\n atom.fragment = None\",\n \"def del_cells(self):\\t\\r\\n del self._cells\",\n \"def removeAll(self):\\n self.pDict.clear()\",\n \"def clean(self):\\n for nodeId in list(self.nodes.keys()):\\n if not self.nodes[nodeId].safe:\\n del self.nodes[nodeId]\",\n \"def remove_from_model(self, destructive=False):\\n self._model.remove_metabolites(self, destructive)\",\n \"def remove_all(self):\\n self.initial = None\\n self.contour = None\\n self.control_points = []\",\n \"def del_lx(self):\\r\\n del self._lx\",\n \"def remove(self):\\n pass\",\n \"def remove(self):\\n pass\",\n \"def remove(self):\\n pass\",\n \"def purge(self):\\n keys = [k for (k, v) in self.get_range()]\\n\\n [self.remove(k) for k in keys]\",\n \"def clear(self):\\r\\n\\t\\tself.free_objects[:] = []\",\n \"def clear(self):\\n for tag in self.meta.findall(CN('meta:user-defined')):\\n self.meta.remove(tag)\",\n \"def reset(self):\\n self.mol.RHF(doPrint=False)\\n self.dipole = []\\n self.angmom = []\\n self.Energy = []\\n self.shape = []\",\n \"def delDimension(self):\\n self.components = []\",\n \"def clear(self):\\n self._nodes = { }\\n self._arcs = set()\",\n \"def clear(self):\\n for vertex in self.vertices():\\n del self[vertex]\",\n \"def clear(self) -> None:\\n self._moments = []\",\n \"def clear_binstar(cli, owner):\\n for channel in cli.list_channels(owner):\\n cli.remove_channel(owner, channel)\\n\\n for package in cli.user_packages(owner):\\n cli.remove_package(owner, package['name'])\",\n \"def remove_eliminated_homes(self):\\n filter_homes = []\\n for home in self.homes:\\n if not home.eliminated:\\n filter_homes.append(home)\\n self.homes = filter_homes\",\n \"def unoccupied(self):\\n self.is_occupied = 0\\n for hex in self.fon:\\n hex.remove_neighbor()\\n hex.set_quality()\",\n \"def delete_all_wells(self):\\n self.wells = []\",\n \"def _remove(self):\\n pass\",\n \"def unload(self):\\n if self.material_background:\\n self.parent.removeItem(self.material_background)\\n self.material_background = None\\n if self.mod_background:\\n self.parent.removeItem(self.mod_background)\\n self.mod_background = None\\n if self.material_foreground:\\n self.parent.removeItem(self.material_foreground)\\n self.material_foreground = None\\n if self.mod_foreground:\\n self.parent.removeItem(self.mod_foreground)\\n self.mod_foreground = None\\n if self.liquid:\\n self.parent.removeItem(self.liquid)\\n self.liquid = None\",\n \"def remove_all_spaces(self):\\n self._register.clear()\",\n \"def clear_extensions(self):\\n self.extensions = set()\",\n \"def delY(self):\\n del self.components[1]\",\n \"def delY(self):\\n del self.components[1]\",\n \"def convertUnbondedAtomToMetaAtom (self,atom):\\r\\n \\r\\n \\r\\n # Create a molecule consisting of just the atom\\r\\n mol = []\\r\\n mol.append(atom)\\r\\n # metaAtomNumber will be the length of the current metaMolecule\\r\\n metaAtomNumber = len(self.metaMolecule.metaAtoms)\\r\\n newMetaAtom = MetaAtom(metaAtomNumber,atom)\\r\\n # Next need to generate metaspikes we can do this by generating a metaspike object then finding the dangling nodes\\r\\n # and tails already created for this spike\\r\\n type1MetaSpike = metSpk.MetaSpike(1,0)\\r\\n type2MetaSpike = metSpk.MetaSpike(2,0)\\r\\n numDanglingNodes = 0\\r\\n numDanglingTails = 0\\r\\n danglingNodesToRemove = []\\r\\n danglingTailsToRemove = []\\r\\n indexType1Spike = 0\\r\\n indexType2Spike = 0\\r\\n for i in range(len(self.metaSpikes)):\\r\\n if self.metaSpikes[i].typeSpike == 1:\\r\\n indexType1Spike = i\\r\\n for j in range(len(self.metaSpikes[i].danglingNodeList)):\\r\\n print (\\\"The length of the dangling node list is: \\\" + str(len(self.metaSpikes[i].danglingNodeList)) + \\\"\\\\n\\\")\\r\\n print (\\\"The value of j is: \\\" + str(j) + \\\"\\\\n\\\")\\r\\n # See if dangling node belongs to atom being removed\\r\\n if self.metaSpikes[i].danglingNodeList[j].spike.RBN == atom:\\r\\n # If so then add to list of nodes being removed\\r\\n type1MetaSpike.addDanglingNode(self.metaSpikes[i].danglingNodeList[j])# Add to metaspike\\r\\n danglingNodesToRemove.append(j)\\r\\n numDanglingNodes += 1\\r\\n else:\\r\\n indexType2Spike = i\\r\\n for j in range(len(self.metaSpikes[i].danglingTailList)):\\r\\n print (\\\"The length of the dangling tail list is: \\\" + str(len(self.metaSpikes[i].danglingTailList)) + \\\"\\\\n\\\")\\r\\n print (\\\"The value of j is: \\\" + str(j) + \\\"\\\\n\\\")\\r\\n # See if dangling tail belongs to atom being removed\\r\\n if self.metaSpikes[i].danglingTailList[j].spike.RBN == atom:\\r\\n # If so then add to list of rails being removed\\r\\n type2MetaSpike.addTailDanglingBonds(self.metaSpikes[i].danglingTailList[j]) # Add to metaspike\\r\\n danglingTailsToRemove.append(j)\\r\\n numDanglingTails += 1 \\r\\n \\r\\n # If any dangling nodes have been found then the spike can be added to the metaAtom\\r\\n if numDanglingNodes > 0: \\r\\n newMetaAtom.addMetaSpike(type1MetaSpike)\\r\\n # Next need to remove danglingNodes no longer located in this metaAtom\\r\\n danglingNodesToRemove.sort(reverse = True) # Sort so popping values doesnt affect other indexes\\r\\n for i in range (len(danglingNodesToRemove)):\\r\\n self.metaSpikes[indexType1Spike].danglingNodeList.pop(danglingNodesToRemove[i])\\r\\n \\r\\n # If any dangling tails have been found then the spike can be added to the metaAtom\\r\\n if numDanglingTails > 0: \\r\\n newMetaAtom.addMetaSpike(type2MetaSpike)\\r\\n # Next need to remove danglingtails no longer located in this metaAtom\\r\\n danglingTailsToRemove.sort(reverse = True) # Sort so popping values doesnt affect other indexes\\r\\n for i in range (len(danglingTailsToRemove)):\\r\\n self.metaSpikes[indexType2Spike].danglingNodeList.pop(danglingTailsToRemove[i])\\r\\n\\r\\n \\r\\n \\r\\n \\r\\n # We repeated this process for dangling tails\\r\\n \\r\\n type2MetaSpike = metSpk.MetaSpike(2,1)\\r\\n \\r\\n numDanglingTails = 0\\r\\n for i in range(len(self.metaSpikes)):\\r\\n if self.metaSpikes[i].typeSpike == 2:\\r\\n for j in range(len(self.metaSpikes[i].danglingTailList)):\\r\\n if self.metaSpikes[i].danglingTailList[j].spike.RBN == atom:\\r\\n type2MetaSpike.addTailDanglingBonds(self.metaSpikes[i].danglingTailList[j])\\r\\n danglingTailsToRemove.append(j)\\r\\n numDanglingTails += 1\\r\\n # If any dangling nodes have been found then the spike can be added to the metaAtom\\r\\n if numDanglingTails > 0: \\r\\n newMetaAtom.addMetaSpike(type2MetaSpike)\\r\\n # Next need to remove danglingNodes no longer located in this metaAtom\\r\\n danglingTailsToRemove.sort(reverse = True) # Sort so popping values doesnt affect other indexes\\r\\n for i in range (len(danglingTailsToRemove)):\\r\\n self.metaSpikes[i].danglingTailList.pop(danglingTailsToRemove[i])\\r\\n \\r\\n return newMetaAtom\",\n \"def clear(self):\\r\\n ElementSet.clear(self)\\r\\n self.update()\",\n \"def full_clear(self):\\n self.clear()\\n self.class_hooks.clear()\",\n \"def remove_abs_vars(self):\\n self.m.remove(self.bp_abs)\\n self.m.remove(self.bn_abs)\\n self.m.remove(self.gp_abs)\\n self.m.remove(self.gn_abs)\\n self.m.remove(self.beta_p)\\n self.m.remove(self.beta_n)\\n self.m.remove(self.gamma_p)\\n self.m.remove(self.gamma_n)\",\n \"def clean(self):\\n\\t\\tfor v in self:\\n\\t\\t\\tv.reset_distance()\\n\\t\\t\\tv.reset_predecessor()\\n\\t\\t\\tv.reset_visited()\",\n \"def CleanUp(self):\\n for Ind in self.IndList():\\n if amax(abs(self[Ind]))<1e-10:\\n del self[Ind]\",\n \"def clearAllElementMetaIdList(self):\\n return _libsbml.Model_clearAllElementMetaIdList(self)\",\n \"def removeAtomStrainDuplicates(self, tol_mag = 7, verbose = 1):\\n\\n keep = self.getAtomStrainDuplicates(tol_mag = tol_mag, verbose = verbose - 1)\\n\\n self.deleteInterfaces(keep = keep, verbose = verbose)\",\n \"def remove_stems(graph = None):\\n\\tfor x,y in basepairs(graph = graph):\\n\\t\\tgraph.remove_node(x)\\n\\t\\tgraph.remove_node(y)\",\n \"def delete_all(self):\\n for tag in self._segments['APP1'].get_tag_list():\\n try:\\n self.__delattr__(tag)\\n except AttributeError:\\n warnings.warn(\\\"could not delete tag \\\" + tag, RuntimeWarning)\",\n \"def remove(self, egg):\",\n \"def remove(self) -> None:\\n self.map.cordons.remove(self)\",\n \"def clear(self) -> None:\\n # Delete these so the .by_class/name values are cleared.\\n self['classname'] = 'info_null'\\n del self['targetname']\\n self._keys.clear()\\n # Clear $fixup as well.\\n self._fixup = None\",\n \"def clear(self) -> None:\\n logger.info(\\\"destroying all registered mutants\\\")\\n try:\\n uuids = list(self)\\n for uuid in uuids:\\n del self[uuid]\\n except Exception:\\n logger.exception(\\\"failed to destroy all registered mutants\\\")\\n raise\\n logger.info(\\\"destroyed all registered mutants\\\")\",\n \"def _RemoveFromCloneList(self, clone, attrNamesToClone):\\n attrNamesToClone = super(EquationUnit, self)._RemoveFromCloneList(clone, attrNamesToClone)\\n \\n dontClone = [\\\"_Funcs\\\", \\\"_FuncsDefs\\\"]\\n \\n for name in dontClone:\\n if name in attrNamesToClone:\\n attrNamesToClone.remove(name)\\n \\n return attrNamesToClone\",\n \"def reset(self):\\n self.entities = set()\\n self.frozen = False\",\n \"def removeDegenerate(self):\\n return self[~self.testDegenerate()]\",\n \"def clear_dummy_obj(self):\\n for d in self.dummies:\\n self.map.remove_node(d)\\n\\n self.dummies = []\",\n \"def prune(self): # HashMap.prune\\n for hashval, list in self.contentHash.iteritems():\\n newlist=[]\\n for entry in list:\\n if not entry.deleted:\\n newlist.append(entry)\\n self.contentHash[hashval]=newlist\",\n \"def clear(self):\\n self.chromosome_list = []\",\n \"def clear(self):\",\n \"def clear(self):\",\n \"def clear(self):\",\n \"def clear(self):\",\n \"def clear(self):\",\n \"def clear(self):\",\n \"def clear(self):\",\n \"def unload(self) -> None:\\n for attr in self._attrs:\\n setattr(self, attr, None)\",\n \"def del_lz(self):\\r\\n del self._lz\",\n \"def delete_lattice(): \\n # Delete the existing lattice\\n for o in bpy.data.objects:\\n if o.type == 'LATTICE':\\n # Delete the existing lattice\\n object_to_delete = bpy.data.objects[\\\"Lattice\\\"]\\n bpy.data.objects.remove(object_to_delete, do_unlink=True)\",\n \"def remove_tactic(self):\\n tactic_removed = input(\\\"Enter a tactic to be removed: \\\")\\n self.proof.tactics.remove(tactic_removed)\\n for gene in self.population:\\n gene.chromosome = [e for e in gene.chromosome if e != tactic_removed]\",\n \"def clear_structure(self):\\n self.structure = []\\n return\",\n \"def cleanup(self):\\n for attribute in self._all_db_field_names:\\n delattr(self, attribute)\",\n \"def parse_hydrogen(self, res, topo):\\n name = self.map[res].name\\n opttype = self.map[res].opttype\\n optangle = self.map[res].optangle\\n map_ = self.map[res].map\\n mydef = HydrogenDefinition(name, opttype, optangle, map_)\\n patch_map = []\\n atoms = []\\n refatoms = []\\n conformernames = []\\n refmap = {}\\n titrationstatemap = {}\\n tautomermap = {}\\n conformermap = {}\\n atommap = {}\\n ntrmap = {}\\n hmap = {}\\n nonhmap = {}\\n # reference map from TOPOLOGY.xml\\n for res_ in topo.residues:\\n refmap[res_.name] = res_.reference\\n for atom in refmap[res_.name].atoms:\\n atommap[res_.name, atom.name] = atom\\n for titrationstate in res_.titration_states:\\n titrationstatemap[titrationstate.name] = titrationstate\\n for tautomer in titrationstate.tautomers:\\n tautomermap[tautomer.name] = tautomer\\n for conformer in tautomer.conformers:\\n conformermap[conformer.name] = conformer\\n if name == \\\"CYS\\\":\\n _ = refmap[\\\"CYS\\\"]\\n atoms = [\\\"HG\\\"]\\n refatoms = [\\\"SG\\\", \\\"CB\\\"]\\n elif name == \\\"HIS\\\":\\n _ = refmap[\\\"HIS\\\"]\\n atoms = [\\\"HD1\\\", \\\"HE2\\\"]\\n for atom in atoms:\\n refatoms = [\\\"ND1\\\", \\\"CG\\\", \\\"CE1\\\"]\\n elif name == \\\"LYS\\\":\\n _ = self.debumper.biomolecule.reference_map[name]\\n patch_map = self.debumper.biomolecule.patch_map[\\\"LYN\\\"]\\n atoms = patch_map.remove\\n refatoms = [\\\"HZ1\\\", \\\"HZ2\\\", \\\"NZ\\\"]\\n elif name == \\\"TYR\\\":\\n _ = self.debumper.biomolecule.reference_map[name]\\n patch_map = self.debumper.biomolecule.patch_map[\\\"TYM\\\"]\\n atoms = patch_map.remove\\n refatoms = [\\\"OH\\\", \\\"CZ\\\", \\\"CE2\\\"]\\n elif name == \\\"WAT\\\":\\n _ = self.debumper.biomolecule.reference_map[name]\\n patch_map = self.debumper.biomolecule.patch_map[\\\"HOH\\\"]\\n atoms = [\\\"H1\\\", \\\"H2\\\"]\\n refatoms = None\\n elif name == \\\"NTR\\\":\\n ntrmap = {} # map for N-TERM\\n for tautomer in titrationstatemap[\\\"NTER\\\"].tautomers:\\n for conformer in tautomermap[tautomer.name].conformers:\\n for conformeradds in conformermap[\\n conformer.name\\n ].conformer_adds:\\n for atom in conformeradds.atoms:\\n ntrmap[atom.name] = atom\\n atoms = [\\\"H3\\\", \\\"H2\\\"]\\n refatoms = [\\\"CA\\\", \\\"H\\\", \\\"N\\\"]\\n elif name == \\\"CTR\\\":\\n hmap = {} # map for h atoms\\n nonhmap = {} # map for refatoms\\n conformernames = []\\n for tautomer in titrationstatemap[\\\"CTER\\\"].tautomers:\\n for conformer in tautomermap[tautomer.name].conformers:\\n for conformeradds in conformermap[\\n conformer.name\\n ].conformer_adds:\\n for atom in conformeradds.atoms:\\n nonhmap[atom.name] = atom\\n for tautomer in titrationstatemap[\\\"CTER0\\\"].tautomers:\\n for conformer in tautomermap[tautomer.name].conformers:\\n conformernames.append(conformer.name)\\n for conformeradds in conformermap[\\n conformer.name\\n ].conformer_adds:\\n for atom in conformeradds.atoms:\\n hmap[conformer.name, atom.name] = atom\\n atoms = [\\\"HO\\\"]\\n refatoms = [\\\"O\\\", \\\"C\\\", \\\"OXT\\\"]\\n elif name in [\\\"SER\\\", \\\"GLN\\\", \\\"THR\\\", \\\"ARG\\\", \\\"ASN\\\"]:\\n _ = refmap[name]\\n if name == \\\"SER\\\":\\n atoms = [\\\"HG\\\"]\\n refatoms = [\\\"OG\\\", \\\"CB\\\"]\\n elif name == \\\"GLN\\\":\\n atoms = [\\\"HE21\\\"]\\n refatoms = [\\\"NE2\\\"]\\n elif name == \\\"THR\\\":\\n atoms = [\\\"HG1\\\"]\\n refatoms = [\\\"OG1\\\", \\\"CB\\\"]\\n elif name == \\\"ARG\\\":\\n atoms = [\\\"HH11\\\", \\\"HH12\\\", \\\"HH21\\\", \\\"HH22\\\", \\\"HE\\\"]\\n for atom in atoms:\\n refatoms = [\\\"NH1\\\", \\\"NH2\\\", \\\"CZ\\\"]\\n elif name == \\\"ASN\\\":\\n atoms = [\\\"HD21\\\"]\\n refatoms = [\\\"ND2\\\"]\\n elif name == \\\"ASH\\\":\\n hmap = {} # map for h atoms\\n nonhmap = {} # map for refatoms\\n conformernames = []\\n _ = refmap[\\\"ASP\\\"]\\n for tautomer in titrationstatemap[\\\"ASH\\\"].tautomers:\\n for conformer in tautomermap[tautomer.name].conformers:\\n for conformeradds in conformermap[\\n conformer.name\\n ].conformer_adds:\\n for atom in conformeradds.atoms:\\n hmap[conformer.name, atom.name] = atom\\n conformernames.append(conformer.name)\\n atoms = [\\\"HD1\\\", \\\"HD2\\\"]\\n refatoms = [\\\"OD1\\\", \\\"CG\\\", \\\"OD2\\\"]\\n elif name == \\\"GLH\\\":\\n hmap = {} # map for h atoms\\n nonhmap = {} # map for refatoms\\n conformernames = []\\n _ = refmap[\\\"GLU\\\"]\\n for tautomer in titrationstatemap[\\\"GLH\\\"].tautomers:\\n for conformer in tautomermap[tautomer.name].conformers:\\n for conformeradds in conformermap[\\n conformer.name\\n ].conformer_adds:\\n for atom in conformeradds.atoms:\\n hmap[conformer.name, atom.name] = atom\\n conformernames.append(conformer.name)\\n atoms = [\\\"HE1\\\", \\\"HE2\\\"]\\n refatoms = [\\\"OE1\\\", \\\"CD\\\", \\\"OE2\\\"]\\n else:\\n patch_map = self.debumper.biomolecule.patch_map[name]\\n atoms = list(patch_map.map.keys())\\n atoms.sort()\\n if name in [\\\"NTR\\\"]:\\n bondlength = 1.0\\n for atom in atoms:\\n hname = atom\\n x = ntrmap[hname].x\\n y = ntrmap[hname].y\\n z = ntrmap[hname].z\\n bondatom = ntrmap[hname].bonds[0]\\n myconf = HydrogenConformation(hname, bondatom, bondlength)\\n atom = defns.DefinitionAtom(hname, x, y, z)\\n myconf.add_atom(atom)\\n\\n # TODO - lots of arbitrary undefined numbers in this section\\n for atom_ in refatoms:\\n if atom_ == \\\"N\\\":\\n natom = defns.DefinitionAtom(atom_, 1.201, 0.847, 0.0)\\n myconf.add_atom(natom)\\n elif atom_ == \\\"CA\\\":\\n caatom = defns.DefinitionAtom(atom_, 0.0, 0.0, 0.0)\\n myconf.add_atom(caatom)\\n elif atom_ == \\\"H\\\":\\n caatom = defns.DefinitionAtom(\\n atom_, 1.201, 1.847, 0.000\\n )\\n myconf.add_atom(caatom)\\n mydef.add_conf(myconf)\\n elif name in [\\\"CTR\\\"]:\\n bondlength = 1.0\\n for conformer in conformernames:\\n for atom in atoms:\\n hname = atom\\n x = hmap[conformer, hname].x\\n y = hmap[conformer, hname].y\\n z = hmap[conformer, hname].z\\n bondatom = hmap[conformer, hname].bonds[0]\\n myconf = HydrogenConformation(hname, bondatom, bondlength)\\n atom = defns.DefinitionAtom(hname, x, y, z)\\n myconf.add_atom(atom)\\n\\n # TODO - the following code is almost nonsensical\\n for atom_ in refatoms:\\n if atom_ == \\\"C\\\":\\n catom = defns.DefinitionAtom(\\n atom_, -1.250, 0.881, 0.000\\n )\\n myconf.add_atom(catom)\\n else:\\n atomname = atom_\\n x = nonhmap[atom_].x\\n y = nonhmap[atom_].y\\n z = nonhmap[atom_].z\\n atom2 = defns.DefinitionAtom(atomname, x, y, z)\\n myconf.add_atom(atom2)\\n mydef.add_conf(myconf)\\n\\n elif name in [\\\"ASH\\\", \\\"GLH\\\"]:\\n for conformer in conformernames:\\n for atom in atoms:\\n hname = atom\\n if (\\\"1\\\" in conformer and \\\"1\\\" in atom) or (\\n \\\"2\\\" in conformer and \\\"2\\\" in atom\\n ):\\n x = hmap[conformer, hname].x\\n y = hmap[conformer, hname].y\\n z = hmap[conformer, hname].z\\n bondatom = hmap[conformer, hname].bonds[0]\\n bondlength = 1.0\\n myconf = HydrogenConformation(\\n hname, bondatom, bondlength\\n )\\n atom = defns.DefinitionAtom(hname, x, y, z)\\n myconf.add_atom(atom)\\n\\n for atom_ in refatoms:\\n atomname = atom_\\n refresname = \\\"\\\"\\n if name == \\\"ASH\\\":\\n refresname = \\\"ASP\\\"\\n elif name == \\\"GLH\\\":\\n refresname = \\\"GLU\\\"\\n x = atommap[refresname, atom_].x\\n y = atommap[refresname, atom_].y\\n z = atommap[refresname, atom_].z\\n atom2 = defns.DefinitionAtom(atomname, x, y, z)\\n myconf.add_atom(atom2)\\n mydef.add_conf(myconf)\\n elif name not in [\\\"WAT\\\"]:\\n bondlength = 1.0\\n for atom in atoms:\\n hname = atom\\n x = atommap[name, hname].x\\n y = atommap[name, hname].y\\n z = atommap[name, hname].z\\n bondatom = atommap[name, hname].bonds[0]\\n myconf = HydrogenConformation(hname, bondatom, bondlength)\\n atom = defns.DefinitionAtom(hname, x, y, z)\\n myconf.add_atom(atom)\\n if refatoms is not None:\\n if name == \\\"HIS\\\" and atom.name == \\\"HE2\\\":\\n refatoms = [\\\"NE2\\\", \\\"CE1\\\", \\\"CD2\\\"]\\n if name == \\\"ARG\\\" and atom.name == \\\"HE\\\":\\n refatoms = [\\\"NE\\\", \\\"CZ\\\", \\\"NH1\\\"]\\n # FIXME: 2020/07/06 intendo - the \\\"atom\\\" is reused in\\n # the outer for loop and ambiguous\\n for atom in refatoms:\\n atomname = atom\\n x = atommap[name, atomname].x\\n y = atommap[name, atomname].y\\n z = atommap[name, atomname].z\\n atom = defns.DefinitionAtom(atomname, x, y, z)\\n myconf.add_atom(atom)\\n mydef.add_conf(myconf)\\n return mydef\",\n \"def destroy(self):\\n for inst in self.module.global_insts[:]:\\n if (inst.op_name in spirv.DECORATION_INSTRUCTIONS or\\n inst.op_name in spirv.DEBUG_INSTRUCTIONS):\\n if self.result_id in inst.operands:\\n inst.destroy()\\n if self.basic_block is None:\\n if self not in self.module.global_insts:\\n raise IRError('Instruction is not in basic block or module')\\n self.module.global_insts.remove(self)\\n return\\n self.basic_block.insts.remove(self)\\n if self.result_id is not None:\\n del self.module.id_to_inst[self.result_id]\\n self.basic_block = None\\n self.op_name = None\\n self.result_id = None\\n self.type_id = None\\n self.operands = None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6937832","0.6847128","0.6714238","0.6525774","0.64063466","0.63946915","0.62644595","0.6262052","0.6121503","0.60625106","0.60625106","0.6042291","0.6015206","0.5961813","0.5960132","0.592724","0.5911329","0.58740425","0.5869668","0.5853029","0.5847566","0.5840705","0.5833174","0.5787099","0.5776653","0.57677335","0.57639223","0.57606786","0.5751832","0.57430935","0.5741274","0.5732762","0.5730973","0.57041174","0.5673703","0.5659852","0.5655323","0.5625569","0.5612792","0.560116","0.55973524","0.55921537","0.55850035","0.55831873","0.5573268","0.5573268","0.5573268","0.5572562","0.5571267","0.5570425","0.5565631","0.55567133","0.5548888","0.5543478","0.5540727","0.55274117","0.5525144","0.5524484","0.5521269","0.55211055","0.55194247","0.5517653","0.551067","0.5502076","0.5502076","0.5500197","0.5496005","0.54911","0.5481963","0.5477364","0.54766905","0.5476186","0.54635966","0.54614806","0.54575616","0.5456814","0.54482466","0.54472005","0.54445165","0.54339266","0.5430146","0.5429851","0.5429524","0.5427501","0.54173166","0.5417313","0.5417313","0.5417313","0.5417313","0.5417313","0.5417313","0.5417313","0.5413941","0.54078954","0.5405436","0.5402282","0.54015267","0.53934985","0.5392373","0.53857416"],"string":"[\n \"0.6937832\",\n \"0.6847128\",\n \"0.6714238\",\n \"0.6525774\",\n \"0.64063466\",\n \"0.63946915\",\n \"0.62644595\",\n \"0.6262052\",\n \"0.6121503\",\n \"0.60625106\",\n \"0.60625106\",\n \"0.6042291\",\n \"0.6015206\",\n \"0.5961813\",\n \"0.5960132\",\n \"0.592724\",\n \"0.5911329\",\n \"0.58740425\",\n \"0.5869668\",\n \"0.5853029\",\n \"0.5847566\",\n \"0.5840705\",\n \"0.5833174\",\n \"0.5787099\",\n \"0.5776653\",\n \"0.57677335\",\n \"0.57639223\",\n \"0.57606786\",\n \"0.5751832\",\n \"0.57430935\",\n \"0.5741274\",\n \"0.5732762\",\n \"0.5730973\",\n \"0.57041174\",\n \"0.5673703\",\n \"0.5659852\",\n \"0.5655323\",\n \"0.5625569\",\n \"0.5612792\",\n \"0.560116\",\n \"0.55973524\",\n \"0.55921537\",\n \"0.55850035\",\n \"0.55831873\",\n \"0.5573268\",\n \"0.5573268\",\n \"0.5573268\",\n \"0.5572562\",\n \"0.5571267\",\n \"0.5570425\",\n \"0.5565631\",\n \"0.55567133\",\n \"0.5548888\",\n \"0.5543478\",\n \"0.5540727\",\n \"0.55274117\",\n \"0.5525144\",\n \"0.5524484\",\n \"0.5521269\",\n \"0.55211055\",\n \"0.55194247\",\n \"0.5517653\",\n \"0.551067\",\n \"0.5502076\",\n \"0.5502076\",\n \"0.5500197\",\n \"0.5496005\",\n \"0.54911\",\n \"0.5481963\",\n \"0.5477364\",\n \"0.54766905\",\n \"0.5476186\",\n \"0.54635966\",\n \"0.54614806\",\n \"0.54575616\",\n \"0.5456814\",\n \"0.54482466\",\n \"0.54472005\",\n \"0.54445165\",\n \"0.54339266\",\n \"0.5430146\",\n \"0.5429851\",\n \"0.5429524\",\n \"0.5427501\",\n \"0.54173166\",\n \"0.5417313\",\n \"0.5417313\",\n \"0.5417313\",\n \"0.5417313\",\n \"0.5417313\",\n \"0.5417313\",\n \"0.5417313\",\n \"0.5413941\",\n \"0.54078954\",\n \"0.5405436\",\n \"0.5402282\",\n \"0.54015267\",\n \"0.53934985\",\n \"0.5392373\",\n \"0.53857416\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7476278"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":399,"cells":{"query":{"kind":"string","value":"collect a set of residues with memb_z within [15, 15]"},"document":{"kind":"string","value":"def memb_residues(pdb: MyPDB) -> list():\n result = []\n for ch in pdb.chains.values():\n for res in ch.values():\n if res.memb_z is not None:\n result.append(res)\n return result"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_subset_mz(self, mz):\n regions = self.boxes_mz.at(mz)\n it = BoxHolder()\n for r in regions:\n box = r.data\n it.add_box(box)\n return it","def get_subset(mlist,year):\n newlist = []\n for entry in mlist:\n if int(entry[0][:4]) > int(year):\n continue\n newvec = entry[:8]\n citations = entry[8]['citations']\n citations = filter(lambda a: int(a[:4]) <= int(year), citations)\n newvec[2] = len(citations)\n newlist.append(newvec)\n return newlist","def filter_pores_by_z(network, pores, z=1):\n pores = network._parse_indices(pores)\n Nz = network.num_neighbors(pores=pores)\n orphans = np.where(Nz == z)[0]\n hits = pores[orphans]\n return hits","def getLigandNbrs(resids: List[Residue], struct:Structure)->List[ResidueDict]:\n\n ns = NeighborSearch(list( struct.get_atoms() ))\n nbrs = []\n\n for r in resids:\n # a ligand consists of residues\n resatoms = r.child_list[0]\n # each residue has an atom plucked at random\n for nbrresidues in ns.search(resatoms.get_coord(), 5,level='R'):\n # we grab all residues in radius around that atom and extend the list of neighbors with those\n nbrs.extend([nbrresidues])\n\n # Filter out the residues that constitute the ligand itself\n filtered = [] \n for neighbor in nbrs:\n present = 0\n for constit in resids:\n if ResidueDict(constit)==ResidueDict( neighbor ):\n present = 1\n if present == 0:\n filtered.append(ResidueDict(neighbor))\n\n return [ * map(lambda x: addBanClass(x) , set(filtered) ) ]","def create_subsets(x, y):\n # initiate empty list for return variables.\n sets_x = []\n sets_y = []\n indices = []\n\n # iterate through value of PRI_JET_NUM (ranged inclusively from 0 until 3)\n for pri_jet_num_val in np.unique(x[:,22]):\n \n # Find subset which DER_MASS_MMC is not equal to -999\n mask = (x[:,22] == pri_jet_num_val) & (x[:,0] != -999)\n x_tmp = x[mask,:]\n y_tmp = y[mask]\n\n # store the subset into list\n sets_x.append(x_tmp)\n sets_y.append(y_tmp)\n indices.append(mask)\n\n # Find subset which DER_MASS_MMC is equal to -999\n mask = (x[:,22] == pri_jet_num_val) & (x[:,0] == -999)\n x_tmp = x[mask,:]\n y_tmp = y[mask]\n\n # store the subset into list\n sets_x.append(x_tmp)\n sets_y.append(y_tmp)\n indices.append(mask) \n \n # return subsets of x, y, and corresponding indices\n return sets_x, sets_y, indices","def get_regions_mask(self, input):","def _find_members(self, given_members):\n if len(list(self.points)) > 3:\n out_mem = [m for m in given_members if\n self.intersects_poly(m.polygon)]\n else:\n out_mem = []\n return out_mem","def fetchCooler(c, regions, coolerFetch = lambda coo, ext:coo.matrix(balance=True, sparse=True).fetch(ext),\n mask=True, force=False, ):\n regions = [list(i) for i in regions]\n resolution = c.binsize\n\n for i in regions:\n if i[1] == None:\n i[1] = 0 \n if i[2] == None:\n i[2] = c.chromsizes[i[0]]\n\n \n for a in regions: \n if str(a[0]) not in c.chromnames:\n raise ValueError(\"Chromosome {0} from regions not found in cooler\".format(a))\n if (a[1] % resolution) != 0:\n raise ValueError(\"Start of an region should be a multiple fo resolution\")\n \n# bins = c.bins()[:]\n \n# # managing masks \n# if mask is False: \n# bins[\"mask\"] = 1 \n# elif mask is None:\n# assert \"mask\" in bins.columns\n# elif mask is True: \n# pass \n# elif callable(mask):\n# pass \n# else:\n# bins[\"mask\"] = mask \n \n \n for region in regions:\n matrix = coolerFetch(c, region)\n try: # setting matrix nans to zeros.\n matrix.data = np.nan_to_num(matrix.data, copy=False)\n except TypeError: #workaround for old numpy versions\n matrix.data = np.nan_to_num(matrix.data)\n# st,end = c.extent(region)\n# subbins = bins[st:end].copy()\n if mask is True: \n newmask = np.array((matrix.sum(axis=0) > 0 ))[0]\n# if callable(mask):\n# new_mask = mask(matrix)\n# subbins[\"mask\"] = newmask \n\n assert len(newmask) == matrix.shape[0]\n\n yield matrix, newmask","def get_relevant_zones(array,threshold=3):\n\n\treturn [item for item in array if len(item)>3]","def roi_vecs(layer_coords, vec_coords, region):\n \n if region == 'crown':\n #find threshold for vectors inside roi\n start_x_lst = []\n stop_x_lst = []\n for i in range(1,5):\n start_x_lst.append(layer_coords[i][0][0])\n stop_x_lst.append(layer_coords[i][-1][0])\n\n start_x = max(start_x_lst)\n stop_x = min(stop_x_lst)\n \n roi_vec_coords = [i for i in vec_coords if i[0][0] in list(range(start_x, stop_x+5))]\n \n return roi_vec_coords\n \n elif region == 'fundus':\n #find threshold for vectors inside roi\n start_x_lst = []\n stop_x_lst = []\n for i in range(1,5):\n start_x_lst.append(layer_coords[i][0][0])\n stop_x_lst.append(layer_coords[i][-1][0])\n\n start_x = max(start_x_lst)\n stop_x = min(stop_x_lst)\n\n # roi_vec_coords = [i for i in vec_coords if i[1][0] in list(range(start_x-10, stop_x+3))]\n roi_vec_coords = [i for i in vec_coords if i[0][0] in list(range(stop_x, start_x))]\n \n # print(roi_vec_coords)\n return roi_vec_coords","def bounds(self, resids: NDArray) -> List[Tuple[float, float]]:","def get_zones(array,kind,relevant=False,threshold=3):\n\n\tresulting_set=[]\n\n\ti=0\n\tif array[i]==kind:\n\t\tcount=1\n\telse:\n\t\tcount=0\n\n\twhile i<len(array):\n\t\t\n\t\tif array[i]==kind:\n\t\t\tcount+=1\n\t\telif array[i]!=kind and array[i-1]==kind:\n\t\t\tresulting_set.append(([kind]*count,i-count))\n\t\t\tcount=0\n\t\telse:\n\t\t\tpass\n\n\t\ti+=1\n\n\tif count>0:\n\t\tresulting_set.append(([kind]*count, i-count))\n\n\tif relevant == False:\n\t\treturn resulting_set\n\telse:\n\t\treturn [item for item in resulting_set if len(item[0])>threshold]","def _get_ring_nodes(m, namin=3, namax=9, remove_redudant=T):\n # first search for rings\n sets = []\n for i in range(namin, namax+1):\n #if i in [3,4,5]:\n pat_i = '*~1' + '~*'*(i-2) + '~*1'\n #else:\n # pat_i = '*:1' + ':*'*(i-2) + ':*1'\n Qi = Chem.MolFromSmarts( pat_i )\n for tsi in m.GetSubstructMatches(Qi):\n set_i = set(tsi)\n if set_i not in sets:\n sets.append( set(tsi) )\n if remove_redudant:\n # now remove those rings that are union of smaller rings\n n = len(sets)\n sets_remove = []\n ijs = itl.combinations( list(range(n)), 2 )\n sets_u = []\n for i,j in ijs:\n set_ij = sets[i].union( sets[j] )\n if (set_ij in sets) and (set_ij not in sets_remove):\n sets_remove.append( set_ij )\n sets_u = cim.get_compl(sets, sets_remove)\n else:\n sets_u = sets\n return sets_u","def get_feats(mz_list,intensity_list,feat_matrix,instance_index,feats,max_dist=275,allowed_c=[]):\n\t# UNCOMMENT var below if standard library combinations is used\n\t#allowed_c = set(allowed_c)\n\t\n\tspectrum = zip(mz_list,intensity_list)\n\tdists_mz = []\n\tdists_mz_intens = []\n\tprev_analyzed = set()\n\t\n\t#Make deepcopy since we are going to change the spectra!\n\tspec_one = copy.deepcopy(spectrum)\n\tspec_two = copy.deepcopy(spectrum)\n\t\n\t#Iterate over the peaks and measure the distance in m/z between all combinations\n\tfor peak_one in spec_one:\n\t\tif len(spec_two) == 1: continue\n\t\tspec_two = spec_two[1:]\n\t\tfor peak_two in spec_two:\n\t\t\tdist_mz = abs(peak_one[0]-peak_two[0])\n\t\t\tif dist_mz > max_dist: break\n\t\t\tdists_mz.append(dist_mz)\n\t\t\tdists_mz_intens.append(peak_one[1]+peak_two[1])\n\t\n\t# UNCOMMENT code below if standard library combinations is used\n\t#for c in combinations(spectrum,2):\n\t#\tdist_mz = abs(c[0][0]-c[1][0])\n\t#\tif c[0][0] in prev_analyzed: continue\n\t#\tif dist_mz > max_dist: \n\t#\t\tprev_analyzed.add(c[0][0])\n\t#\t\tcontinue\n\t#\tif len(allowed_c) != 0:\n\t#\t\tif dist_mz not in allowed_c: continue\n\t#\tdists_mz.append(dist_mz)\n\t#\tdists_mz_intens.append(c[0][1]+c[1][1])\n\t\n\t#Digitize the delta m/z; assign bins for all delta m/z s\n\tindex_bins = np.digitize(dists_mz,feats)\n\t\n\t#Iterate over assigned bins and sum the intensity for possible existing values\n\tfor index,intens in zip(index_bins,dists_mz_intens):\n\t\tfeat_matrix[instance_index,index-1] += intens\n\n\treturn(feat_matrix)","def get_data(n):\n data = pd.read_csv('map_data/lior_results_2.csv')\n data = data.drop(['estimated_mass', 'estimated_pop'], axis=1)\n data = data[data.binomial != 'Sus scrofa'] # Wild Boar\n data = data[data.binomial != 'Ursus maritimus'] # Polar bear\n data = data[data.binomial != 'Sus bucculentus'] # EX\n data = data[data.binomial != 'Melomys rubicola'] # EX\n data = data.assign(total_mass=data.AdultBodyMassG * data.pop_density * data.Range,\n total_mass_density=data.AdultBodyMassG * data.pop_density)\n data = data.sort_values(by='total_mass_density', ascending=False)\n data = data.iloc[0:n - 1]\n geo_data = gpd.read_file('TERRESTRIAL_MAMMALS/TERRESTRIAL_MAMMALS.shp').to_crs(\"EPSG:6933\")\n geo_data = geo_data[geo_data.category != 'EX']\n range_polygons = geo_data.loc[(geo_data['legend'] == 'Extant & Introduced (resident)') |\n (geo_data['legend'] == 'Extant & Origin Uncertain (resident)') |\n (geo_data['legend'] == 'Extant & Reintroduced (resident)') |\n (geo_data['legend'] == 'Extant & Vagrant (seasonality uncertain)') |\n (geo_data['legend'] == 'Extant (non breeding)') |\n (geo_data['legend'] == 'Extant (resident)') |\n (geo_data['legend'] == 'Probably Extant & Origin Uncertain (resident)') |\n (geo_data['legend'] == 'Probably Extant (resident)') |\n (geo_data['legend'] == 'Reintroduced')]\n range_polygons = range_polygons.merge(data, on='binomial')\n range_polygons = range_polygons.to_crs(\"EPSG:6933\")\n return range_polygons","def items():\n for i in self._iter_restrict(zeros, ones):\n yield self.pcdata[i]","def check_point(self, mz, rt):\n regions = self.boxes_mz.at(mz)\n hits = set()\n for r in regions:\n if r.data.rt_match(rt):\n hits.add(r.data)\n return hits","def get_carboxyl_map(atom_list):\n carboxyl_map = [[atom_list[x], atom_list[x+1], atom_list[x+2], atom_list[x+3]] for x in range(len(atom_list)-3) if ((atom_list[x].residue_name == atom_list[x+1].residue_name == atom_list[x+2].residue_name == atom_list[x+3].residue_name == \"C1A\") and (atom_list[x].residue_number == atom_list[x+1].residue_number == atom_list[x+2].residue_number == atom_list[x+3].residue_number) and (atom_list[x].atom_name != \"CY\" != atom_list[x+1].atom_name != atom_list[x+2].atom_name != \"CY\" != atom_list[x+3].atom_name ))]\n return carboxyl_map","def filter_residues(residues, biomolecule='PROTEIN'):\n biomolecule = biomolecule.strip().upper()\n standard_residues = []\n for res in residues:\n if res.get_resname().strip() in STANDARD_RESIDUES[biomolecule]:\n if not res.id[0].strip(): standard_residues.append(res) # filter out hetro residues\n return standard_residues","def get_obstList(self,X,Y,Z):\n\n x = np.array(X); y = np.array(Y); z = np.array(Z);\n dist = (x - self.x_c)**2 + (y - self.y_c)**2 + (z - self.z_c)**2\n \n return list(np.where(dist < self.r**2))","def get_obstList(self,X,Y,Z):\n\n x = np.array(X); y = np.array(Y); z = np.array(Z);\n dist = (x - self.x_c)**2 + (y - self.y_c)**2 + (z - self.z_c)**2\n \n return list(np.where(dist < self.r**2))","def select_regions(binary,f,min=0,nbest=100000):\n if binary.max() == 1:\n labels,_ = label(binary)\n else:\n labels = binary.astype(uint8)\n objects = find_objects(labels)\n scores = [f(o) for o in objects]\n best = argsort(scores)\n keep = zeros(len(objects)+1,'i')\n if nbest > 0:\n for i in best[-nbest:]:\n if scores[i]<=min: continue\n keep[i+1] = 1\n # print scores,best[-nbest:],keep\n # print sorted(list(set(labels.ravel())))\n # print sorted(list(set(keep[labels].ravel())))\n return keep[labels]","def findSubsetIndices(grdMODEL, min_lat, max_lat, min_lon, max_lon):\n\n\n if min_lon<0 and max_lon>0:\n splitExtract = True; Turns=2\n grdMODEL.splitExtract=splitExtract\n else:\n splitExtract = False; Turns=1\n grdMODEL.splitExtract=splitExtract\n grdMODEL.lon = np.where(grdMODEL.lon>180,grdMODEL.lon-360,grdMODEL.lon)\n \n # Array to store the results returned from the function\n res=np.zeros((Turns,4),dtype=np.float64)\n \n lats=grdMODEL.lat[:,0]\n lons=grdMODEL.lon[0,:]\n\n \n for k in range(Turns):\n\n if k==0 and splitExtract == True:\n minLon=min_lon; maxLon=0\n minLon=minLon+360\n maxLon=maxLon+360\n elif k==1 and splitExtract == True:\n minLon=0; maxLon=max_lon\n else:\n minLon=min_lon; maxLon=max_lon\n \n distances1 = []\n distances2 = []\n indices=[]\n index=1\n for point in lats:\n s1 = max_lat-point # (vector subtract)\n s2 = min_lat-point # (vector subtract)\n distances1.append((np.dot(s1, s1), point, index))\n distances2.append((np.dot(s2, s2), point, index-1))\n index=index+1\n\n distances1.sort()\n distances2.sort()\n indices.append(distances1[0])\n indices.append(distances2[0])\n \n distances1 = []\n distances2 = []\n index=1\n \n for point in lons:\n s1 = maxLon-point # (vector subtract)\n s2 = minLon-point # (vector subtract)\n distances1.append((np.dot(s1, s1), point, index))\n distances2.append((np.dot(s2, s2), point, index-1))\n index=index+1\n \n distances1.sort()\n distances2.sort()\n indices.append(distances1[0])\n indices.append(distances2[0])\n\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\n minJ=indices[1][2]\n maxJ=indices[0][2]\n minI=indices[3][2]\n maxI=indices[2][2]\n \n res[k,0]=minI; res[k,1]=maxI; res[k,2]=minJ; res[k,3]=maxJ;\n\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\n grdMODEL.indices=res","def extract_upstream_for_meme(genomes, locuses, upstream, radius, overlap):\n\n records = []\n for genome in genomes:\n feature_len = len(genome.features)\n\n index = 0\n locations = set()\n for feature in filter(lambda f: f.type == \"CDS\", genome.features):\n locus = feature.qualifiers[\"locus_tag\"][0] \n if locus in locuses:\n locations.add(index)\n for i in range(index - radius, index + radius):\n locations.add(i)\n \n index += 1\n\n print(locations)\n records += extract_upstream(locations, genome, upstream, overlap)\n\n return records","def getratios(results_condition,conditions):\n setlist = {}\n for r in range(conditions):\n setlist[r] = []\n \n for gene in results_condition.genelist:\n conditions = len(gene.logfold)\n\n count = 0\n for set_ in setlist:\n if gene.logfold[count] > 1.5 or gene.logfold[count] < -1.5 :\n setlist[count].append(gene.name)\n count +=1\n return setlist","def extract_pi_region(vcf_file,chrom,start,end,mincov=0,maxcov=10000,inds=\"all\",bgzip=True,min_nsites=0,min_variants=0,verbose=\"min\",called=True,output=\"pi\"):\n\tinput_vcf=vcf.Reader(fsock=None, filename=vcf_file, compressed=bgzip, prepend_chr=\"False\", strict_whitespace=False)#open the vcf parser\n\tif inds==\"all\" or inds==[\"all\"]:inds=input_vcf.samples# transform \"all\" in a list of all individuals in the vcf\n\t#Function\n\tpi_values=[]#list \n\tnsites_considered=0#iterator for sampling frequency\n\ttotal_nsites=0\n\tnvariants=0# iterator for sites that are varying\n\t###identify individual to remove when calculating stats\n\tinds_to_delete=[]\n\tfor i,ind in enumerate(input_vcf.samples):#check which ind is ion sample and compare it to our list of inds\n\t\t if ind not in inds:#delete this ind\n\t\t \tinds_to_delete.append(i)\n\t#go along the region\n\tif chrom!=\"all\":\n\t\tfor record in input_vcf.fetch(chrom,start,end):# for every site\n\t\t\tcond=checkRecord_Cov(input_vcf,record,mincov,maxcov,inds=inds,called=True,nalleles=[1,2])# check if the site respect our condition\n\t\t\ttotal_nsites+=1\n\t\t\tif cond:# if it does\n\t\t\t\tnsites_considered+=1 \n\t\t\t \tif total_nsites%100000==0: print total_nsites,\"sites\",nsites_considered,\"sites passed filter\"\n\t\t\t \tfor index in sorted(inds_to_delete)[::-1]:#remove the individuals we do not want\n\t\t\t \t\tdel record.samples[index]\n\t\t\t \tif verbose==True:print record.POS\n\t\t\t \tif verbose==True:print \"inds\",inds\t\t \t\n\t\t\t \tif verbose==True:print \"GT\",[sample[\"GT\"] for sample in record.samples] \n\t\t\t \tif verbose==True:print \"DP\",[sample[\"DP\"] for sample in record.samples]\n\t\t\t\tpi_values.append(record.nucl_diversity)#calculate pi\n\t\t\t\tif record.nucl_diversity>0.0:nvariants+=1\n\t\t\t#compute total information for the window\n\telif chrom==\"all\":\n\t\tfor record in input_vcf:# for every site\n\t\t\tcond=checkRecord_Cov(input_vcf,record,mincov,maxcov,inds=inds,called=True,nalleles=[1,2])# check if the site respect our condition\n\t\t\ttotal_nsites+=1\n\t\t\tif cond:# if it does\n\t\t\t\tnsites_considered+=1\n\t\t\t \tif total_nsites%100000==0: print total_nsites,\"sites\",nsites_considered,\"sites passed filter\"\n\t\t\t \tfor index in sorted(inds_to_delete)[::-1]:#remove the individuals we do not want\n\t\t\t \t\tdel record.samples[index]\n\t\t\t \tif verbose==True:print record.POS\n\t\t\t \tif verbose==True:print \"inds\",inds\t\t \t\n\t\t\t \tif verbose==True:print \"GT\",[sample[\"GT\"] for sample in record.samples] \n\t\t\t \tif verbose==True:print \"DP\",[sample[\"DP\"] for sample in record.samples]\n\t\t\t\tpi_values.append(record.nucl_diversity)#calculate pi\n\t\t\t\tif record.nucl_diversity>0.0:nvariants+=1\n\tif verbose==True or verbose==\"min\":print \"nvariants:\",nvariants,\"nsites_considered:\",nsites_considered\n\tif output==\"pi\":\n\t\tif nsites_considered>=min_nsites and nvariants>=min_variants and len(pi_values):\n\t\t\tpi_value=sum(pi_values)/nsites_considered\t\t\n\t\t\treturn pi_value\n\t\telse:\n\t\t\treturn \"NA\"\n\telif output==\"extended\":\n\t\tif nsites_considered>=min_nsites and nvariants>=min_variants and len(pi_values):\n\t\t\tpi_value=sum(pi_values)/nsites_considered\t\t\n\t\t\treturn [nvariants,nsites_considered,pi_value]\n\t\telse:\n\t\t\treturn [nvariants,nsites_considered,\"NA\"]\n\telse:\n\t\traise Exception(\"incorrect output argumnent, should be pi or extended\")","def getIndexes(z_nummers):\n sortCriteria = util.get_prop(\"ixsm\")\n if not sortCriteria:\n sortCriteria = \"z_index\"\n sortCriteria = \"ORDER BY z_nummer, %s\" % sortCriteria\n return getRecordsByAttributeIn(\"zeichnung\", \"z_nummer\", z_nummers, addtl=sortCriteria)","def find_own_objects(cs):\n own_objects = {}\n for con in cs:\n own_objects[con] = []\n for obj in con.extent:\n own_objects[con].append(obj)\n for sub_con in cs:\n if sub_con.extent < con.extent and\\\n obj in sub_con.extent:\n own_objects[con].pop()\n break\n return own_objects","def find_progenitors_at_z(self, SH, mtree, z1, z2):\n \n for ss in range(z1, z2):\n # nodes at redshift ss\n ss_indx = np.where(mtree.data.snapshotNumber.values == ss)\n nodeID = mtree.data.index.values[ss_indx]\n nodeID_desc = mtree.data.descendantIndex.values[ss_indx]\n \n # find number of progenitors for nodes at redshift ss\n if ss != z1:\n _progcounts = np.zeros(len(nodeID))\n for ii in range(len(nodeID_past_desc)):\n if nodeID_past_desc[ii] in nodeID:\n indx = np.where(nodeID == nodeID_past_desc[ii])\n _progcounts[indx] = count[ii]\n\n nodeID_desc_unique, count = np.unique(nodeID_desc, return_counts=True)\n nodeID_desc_unique=nodeID_desc_unique[1:]; count=count[1:]\n \n nodeID_past = nodeID\n nodeID_past_desc = nodeID_desc_unique\n if ss != z1:\n _progcounts_past = _progcounts\n print('_progcounts', _progcounts)","def find_nearby_membranes(all_membranes, all_membrane_map, vert_normals):\r\n membrane_tree = scipy.spatial.cKDTree(all_membranes)\r\n nearby_membranes = np.array(list(membrane_tree.query_pairs(adhesion_max_dist, p=2)))\r\n nearby_membrane_map = defaultdict(list)\r\n if nearby_membranes.shape[0] > 0:\r\n # Exclude same-cell membrane interactions and same-direction-facing segments\r\n all_vert_normals = np.concatenate(vert_normals, axis=0)\r\n subset = np.where(\r\n (all_membrane_map[nearby_membranes[:, 0], 0] !=\r\n all_membrane_map[nearby_membranes[:, 1], 0])\r\n & (np.einsum('ij,ik->i', all_vert_normals[nearby_membranes[:, 0]], all_vert_normals[nearby_membranes[:, 1]]) < 0.0)\r\n )\r\n nearby_membranes = nearby_membranes[subset]\r\n # {cell idx: (vert idx, other cell idx, other vert idx, 'all_membranes' vert idx)}\r\n for nm in nearby_membranes:\r\n m0 = all_membrane_map[nm[0]]\r\n m1 = all_membrane_map[nm[1]]\r\n nearby_membrane_map[m0[0]].append((m0[1], m1[0], m1[1], nm[1]))\r\n nearby_membrane_map[m1[0]].append((m1[1], m0[0], m0[1], nm[0]))\r\n nearby_membrane_map = {k: np.array(v)\r\n for k, v in nearby_membrane_map.items()}\r\n# print(nearby_membrane_map)\r\n return nearby_membranes, nearby_membrane_map","def xz_plane(blkmap, y):\n result = []\n base = y*blkmap.plane_span\n z = 0\n while z < blkmap.plane_span:\n start = base + z\n z += blkmap.row_span\n end = base + z\n result.append(tuple(blkmap.blocks[start:end]))\n\n return result","def get_z_ranges(self):\n\n summary = self.get_rasters_summary()\n\n # Convert to dict in format:\n # { 'stat' : { 'z': (min, max), ... } ... }\n\n ranges = summary.groupby(['stat', 'z'], as_index=False)\n ranges = ranges.agg({'min': 'min', 'max': 'max'})\n ranges['vals'] = ranges.apply(\n lambda row: {\n row['z']: (row['min'], row['max'])\n }, axis=1)\n ranges = ranges.groupby('stat')['vals'].apply(\n lambda group: group.values)\n ranges = ranges.apply(\n lambda group: {\n int(k): v for d in group for k,\n v in d.items()})\n\n return ranges.to_dict()","def pixelise_region(coordinates, shapefile):\n return [coordinate for coordinate in coordinates if\n (np.sum(shapefile['geometry'].apply(lambda x: Point(coordinate[1], coordinate[0]).within(x))) != 0) |\n (np.sum(shapefile['geometry'].apply(lambda x: Point(coordinate[3], coordinate[0]).within(x))) != 0) |\n (np.sum(shapefile['geometry'].apply(lambda x: Point(coordinate[1], coordinate[2]).within(x))) != 0) |\n (np.sum(shapefile['geometry'].apply(lambda x: Point(coordinate[3], coordinate[2]).within(x))) != 0)]","def __iteratively_retain(\n self,\n orf_regions: List[Tuple[int, int]]) -> List[Tuple[int, int]]:\n\n ret = []\n\n arr = np.zeros((len(self.seq), ))\n\n for start, end in orf_regions:\n ret.append((start, end))\n arr[start-1:end] = 1\n orf_coverage = np.sum(arr) / len(arr)\n if orf_coverage > self.min_orf_coverage:\n break\n\n return ret","def get_subregions(xint,conn):\n\n subregions = ('SELECT DISTINCT cvt.name, fip.value, f.name '\n 'FROM interaction i, feature_interaction fi, feature_interactionprop fip, ' \n 'feature f, cvterm cvt, cvterm cvt2, feature_relationship fr, feature f2 '\n 'WHERE f.feature_id = fi.feature_id AND fi.interaction_id = i.interaction_id '\n 'AND fi.feature_interaction_id = fip.feature_interaction_id '\n 'AND fi.role_id = cvt.cvterm_id '\n 'AND fip.type_id = cvt2.cvterm_id AND '\n 'cvt2.name = \\'subpart_info\\' AND f.feature_id = fr.subject_id '\n 'AND f2.feature_id = fr.object_id AND f.is_obsolete = \\'f\\' AND '\n 'f2.uniquename = %s AND i.uniquename = %s')\n subs = connect(subregions,xint,conn)\n return(subs)","def findlines(z,bgsub=True,SATURATED=57000.):\n z = z.copy()\n s = z.copy()\n\n \"\"\" First identify peaks. \"\"\"\n max = ndimage.maximum_filter(z,9)\n p = scipy.where((max==z)&(z<SATURATED)&(max>0))[0]\n s = z[p]\n\n \"\"\" Reject low peaks. \"\"\"\n bg = ndimage.percentile_filter(s,10,21)\n peaks = scipy.where(s>bg*5.)[0]\n return p[peaks]","def get_protein_from_mz(self, mz, ppm=None, match_name=\"name\", data_slot=\"mzWeight\"):\n\n possibleMatches = []\n\n ppmDist = self.get_ppm(mz, ppm)\n overlaps = self.mz_tree.overlap(mz-ppmDist, mz+ppmDist)\n for overlap in overlaps:\n \n protMass = overlap[2][data_slot]\n protDist = abs(mz-protMass)\n \n for name in overlap[2][match_name]:\n possibleMatches.append((name, protMass, protDist))\n\n possibleMatches = sorted(possibleMatches, key=lambda x: x[2])\n possibleMatches = [(x[0], x[1]) for x in possibleMatches]\n\n return possibleMatches","def test_subset_reconstruction_iterable(self, wires):\n circuit = hadamard_circuit(wires)\n bits, recipes = circuit()\n shadow = ClassicalShadow(bits, recipes)\n\n # choose 1000 random indices\n snapshots = np.random.choice(np.arange(10000, dtype=np.int64), size=1000, replace=False)\n state = shadow.global_snapshots(snapshots=snapshots)\n assert state.shape == (len(snapshots), 2**wires, 2**wires)\n\n # check the results against obtaining the full global snapshots\n expected = shadow.global_snapshots()\n for i, t in enumerate(snapshots):\n assert np.allclose(expected[t], state[i])","def filtered_xyz(self) -> tuple[int, int, int]:","def non_mcnugget():\n nugget = [0, 6, 9, 20]\n mcnugget = set([6, 9, 20])\n\n while True:\n mcnugget = set([m+n for m in mcnugget for n in nugget])\n\n for m in mcnugget:\n found = all([m+j in mcnugget for j in range(6)])\n if found:\n return [k for k in range(1, m) if k not in mcnugget]","def select_regions(data, region_col, regions, combine_subregions=True):","def get_points_in_range(self, x, y, z):\n\n return_set = []\n for point in self.get_points():\n min_x = x - 1000\n max_x = x + 1000\n if point[0] < min_x or max_x < point[0]:\n continue\n\n min_y = y - 1000\n max_y = y + 1000\n if point[1] < min_y or max_y < point[1]:\n continue\n\n min_z = z - 1000\n max_z = z + 1000\n if point[2] < min_z or max_z < point[2]:\n continue\n return_set.append(point)\n return return_set","def extract_region_curvilinear(cube, lat_bounds):\n\n cube = cube.copy() \n \n region_mask = create_region_mask(cube.coord('latitude').points, cube.shape, lat_bounds)\n land_ocean_mask = cube.data.mask\n complete_mask = region_mask + land_ocean_mask\n\n cube.data = numpy.ma.asarray(cube.data)\n cube.data.mask = complete_mask\n\n return cube","def defaulter(arr):\n return list(set(map(lambda application: application['customer_id'], filter(lambda application: application['repaid_amount'] < (application['principal'] + application['fee']), arr))))","def all_xs(tran_flag=None):\n xs_ofinterest = {}\n if tran_flag == 'tran':\n xs_ofinterest[\"r\"] = ['abso', 'fiss', 'nufi',\n 'spec', 'tran', 'ener', 'difc', 'tota', 'excs']\n if tran_flag == 'tranXYZ':\n xs_ofinterest[\"r\"] = ['abso', 'fiss', 'nufi', 'spec', 'ener', 'difc', 'tota', 'excs',\n 'tran121', 'tran221', 'tran011', 'tran311', 'tran012', 'tran112', 'tran122', 'tran322', 'tran321', 'tran212', 'tran211', 'tran312', 'tran111', 'tran222', 'tran021', 'tran022']\n xs_ofinterest[\"g\"] = ['1', '2']\n\n return xs_ofinterest","def test08(self):\n a = np.arange(10000) > 5000\n b = bcolz.carray(a, chunklen=100)\n u = b.wheretrue(skip=1020, limit=1020)\n w = b.wheretrue(skip=1030, limit=1030)\n self.assertEqual(a.nonzero()[0].tolist()[1020:2040], list(u))\n self.assertEqual(a.nonzero()[0].tolist()[1030:2060], list(w))","def afindwithin(data):\r\n numfact = len(data[0])-2\r\n withinvec = [0]*numfact\r\n for col in range(1,numfact+1):\r\n rows = pstats.linexand(data,col,pstats.unique(pstats.colex(data,1))[0]) # get 1 level of this factor\r\n if len(pstats.unique(pstats.colex(rows,0))) < len(rows): # if fewer subjects than scores on this factor\r\n withinvec[col-1] = 1\r\n return withinvec","def get_obstList(self,X,Y,Z):\n \n x_c_cone = self.x_c\n\tz_c_cone = self.z_c\n y_c_cone = 0\n x_s = 2.25*2*self.cyl_rad\n rad_cone = x_s + self.cyl_rad\n\th_cone = rad_cone*0.57735\n\n floor_part = np.array(np.where(Y < h_cone)).flatten()\n\n dist = (X - self.x_c)**2 + (Z - self.z_c)**2;\n cyl_part = list(np.array(np.where( dist < self.cyl_rad**2)).flatten())\n\n scour_pit = np.array(np.where( (X - x_c_cone)**2 + (Z - z_c_cone)**2 <= ((self.cyl_rad/cone)/(h_cone))**2*(Y - y_c_cone)**2))\n\n # remove the scour pit from the floor\n obst_list = np.setxor1d(floor_part[:], \n np.intersect1d(floor_part[:],scour_pit[:]))\n\n\n # then add the cylinder\n obst_list = np.union1d(obst_list[:],cyl_part[:])\n \n return list(obst_list[:])","def get_uv_coverage(Nbase, z, ncells, boxsize=None):\n\tif not boxsize: boxsize = c2t.conv.LB\n\tuv_map = np.zeros((ncells,ncells))\n\ttheta_max = c2t.conv.LB/c2t.z_to_cdist(z)\n\tfor p in xrange(Nbase.shape[0]):\n\t\ti,j,k = np.round(Nbase[p,0]*theta_max),np.round(Nbase[p,1]*theta_max),np.round(Nbase[p,2]*theta_max)\n\t\tif np.abs(i)<ncells:\n\t\t\tif np.abs(j)<ncells:\n\t\t\t\tuv_map[int(i),int(j)] += 1\n\treturn uv_map","def create_city_map(n: int) -> set:\n return set((row, col) for row in range(0, n) for col in range(0, n))","def C(v,securite):\n to_return = set()\n x,y = l[v][0],l[v][1]\n a,b = id_case(x,y) #on recupere la case ou se trouve le disque qu'on test\n voisinage = set(cases[a,b]) #on recupere la liste du voisinage (pas forcement contact)\n #4\n #012\n #345\n #678 \n if a>100:\n voisinage = add_list(voisinage,cases[a-4*rayon,b]) #3\n if b>200:\n voisinage = add_list(voisinage,cases[a-4*rayon,b-4*rayon]) #0\n voisinage = add_list(voisinage,cases[a,b-4*rayon]) #1\n if b<600:\n voisinage = add_list(voisinage,cases[a-4*rayon,b+4*rayon]) #6\n voisinage = add_list(voisinage,cases[a,b+4*rayon]) #7\n if a<1100-4*rayon:\n voisinage = add_list(voisinage,cases[a+4*rayon,b]) #5\n if b>200:\n voisinage = add_list(voisinage,cases[a+4*rayon,b-4*rayon]) #2\n voisinage = add_list(voisinage,cases[a,b-4*rayon]) #1\n if b<600:\n voisinage = add_list(voisinage,cases[a+4*rayon,b+4*rayon]) #8\n voisinage = add_list(voisinage,cases[a,b+4*rayon]) #7\n \n #On ajoute plusieurs fois le meme a un ensemble -> pas grave\n for i in voisinage:\n xb,yb = l[i][0],l[i][1]\n if 0<sqrt((x-xb)**2+(y-yb)**2)<=2*rayon+securite:\n to_return.add(i)\n return to_return","def test10(self):\n a = np.arange(1, 11)\n b = bcolz.carray(a)\n bi = b.where(a <= 5)\n ai = (v for v in a if v <= 5)\n self.assertEqual([i for i in ai], [i for i in bi])\n self.assertEqual([i for i in ai], [i for i in bi])","def _setup_all_residues(self, model_num=0):\n all_residues = vector1()\n\n for chain_id in self.get_chain_ids(model_num):\n #print \"ChainID: \"+chain_id\n residues = self.residues(chain_id, model_num)\n all_residues.extend(residues)\n\n return all_residues","def find_unique_elements(molecule_map):\n atoms = []\n for molec_name in molecule_map.keys():\n atoms += [subst['atom'] for subst in molecule_map[molec_name]]\n return set(atoms)","def filter(self, rois):\n can_fragments = np.array([roi.can_fragment for roi in rois])\n return can_fragments","def zmembers(self):\n return self.zrange(0, -1)","def match_regions(self):\n l = []\n for r1 in self.regions_names():\n for r2 in self.metric.index:\n r11 = r1.replace('-', ' ').lower()\n r22 = r2.replace('-', ' ').lower()\n l.append([r1,r2,fuzz.ratio(r11, r22)])\n\n matched = np.array([x for x in l if x[2] > 80])\n\n return {key: value for (key, value) in matched[:,[1,0]]}","def extractstates(self, bias=1.0):\n items = []\n print(\"weights:\")\n print([round(comp.weight, 7) for comp in self.gmm])\n for comp in self.gmm:\n val = comp.weight * float(bias)\n if val > 0.5:\n for _ in range(int(round(val))):\n items.append(deepcopy(comp.loc))\n for x in items: print(x.T)\n return items","def gen_mass_spec(self, mz_lst, bin_num=20000):\n # m2z is from [MZ_MIN, MZ_MAX], with bin_num bins. Note its length is len(hist) + 1\n # intensity: counts from samples in that bin.\n self.intensity, self.m2z = np.histogram(mz_lst, bins=bin_num, range=(MZ_MIN, MZ_MAX))","def mask_range(b, z, lam_em, lam_cent):\n dz = 2. * b * np.sqrt(np.log(2.)) / c\n del_lam = lam_cent * dz\n return lam_cent - del_lam, lam_cent + del_lam","def segregate(primers: list):\n\n group1 = list(filter(lambda primer: 53 <= primer.tm < 58, primers))\n group2 = list(filter(lambda primer: 58 <= primer.tm <= 62, primers))\n\n return group1, group2","def residues(ls):\n # List residue atom index to be restrained\n res_atom_set = set()\n\n # Dictionary of lists with the chain residues selected to be restrained\n # e.g. {chainA:[res1, res15], chainB:[res19, res17]}\n chain_dic = {'': []}\n\n # Fill out the chain dictionary\n i = 0\n while i < len(ls):\n if ls[i].isdigit():\n chain_dic[''].append(int(ls[i]))\n i += 1\n else:\n try:\n chain_dic[ls[i]].append(int(ls[i + 2]))\n except:\n chain_dic[ls[i]] = []\n chain_dic[ls[i]].append(int(ls[i + 2]))\n i += 3\n\n # Loop over the molecular system to select the atom indexes to be selected\n hv = oechem.OEHierView(system, oechem.OEAssumption_BondedResidue + oechem.OEAssumption_ResPerceived)\n for chain in hv.GetChains():\n chain_id = chain.GetChainID()\n if chain_id not in chain_dic:\n continue\n for frag in chain.GetFragments():\n for hres in frag.GetResidues():\n res_num = hres.GetOEResidue().GetResidueNumber()\n if res_num not in chain_dic[chain_id]:\n continue\n for oe_at in hres.GetAtoms():\n res_atom_set.add(oe_at.GetIdx())\n\n return res_atom_set","def dummy_nms(list_maps, prob, parent_idx, scores):# slice_idx=0):\n rval = []\n for slice_idx, maps in zip(parent_idx, list_maps):\n for s in maps:\n # Apply the filter based on proba\n maps[s] = maps[s] * (maps[s] > prob - scores[slice_idx])\n n_z = np.transpose(np.nonzero(maps[s]))\n rval.extend([[s,\n n_z[e, 0], n_z[e, 1],\n maps[s][n_z[e, 0], n_z[e, 1]],\n slice_idx]\n for e in range(len(n_z))])\n #print 'nb of nonzero patches :', len(rval)\n if rval != []:\n rval.sort(key=lambda x: x[3], reverse=True)\n #print 'min :', min(rval, key=lambda x: x[3])\n #print'max :', max(rval, key=lambda x: x[3])\n return rval","def cfdGetOwnersSubArrayForBoundaryPatch(self):\r\n \r\n for iBPatch, theBCInfo in self.cfdBoundaryPatchesArray.items():\r\n \r\n startBFace=self.cfdBoundaryPatchesArray[iBPatch]['startFaceIndex']\r\n \r\n endBFace=startBFace+self.cfdBoundaryPatchesArray[iBPatch]['numberOfBFaces']\r\n \r\n iBFaces=list(range(int(startBFace),int(endBFace))) \r\n \r\n self.cfdBoundaryPatchesArray[iBPatch]['owners_b']=[self.owners[i] for i in iBFaces]","def get_all_bandgaps(cluster, spin_list, dir=\"/home/pv278/Platinum/\"):\n E, s = [], []\n for spin in spin_list:\n Ebg = get_bandgap(cluster, spin, dir)\n if Ebg:\n E.append(Ebg)\n s.append(spin)\n return np.vstack((s,E)).T","def slice_zvals(self):\n return np.sort([z.val for z in self.zvals])","def all_subconstituents(self, compute=False):\n out = {}\n for i in range(self._.d+1):\n try:\n out[i] = self.subconstituent(i, compute=compute)\n except IndexError:\n pass\n return out","def find_features_geojson(self, geojson_tagset):\n kreis_region_bund_list = []\n only_regs_set = set()\n for feature in geojson_tagset:\n bundesl = feature.properties.get('NAME_1')\n region = feature.properties.get('NAME_2')\n kreis = feature.properties.get('NAME_3')\n\n kreis_region_bund_list.append((kreis, region, bundesl))\n #Check: does \"Göttingen\" appear in this list as a region? Why does Goettingen need to be a region?)\n return kreis_region_bund_list","def subdata(min_,dict_):\n list_ = []\n return [value for value,freq in dict_.items() if freq > min_]","def get_element_indices_within_rectangle(self, xmin, xmax, zmin, zmax):\n centroids = self.get_element_centroids()\n indices_list = []\n for nr, (x, z) in enumerate(centroids):\n if x >= xmin and x <= xmax and z >= zmin and z <= zmax:\n indices_list.append(nr)\n return np.array(indices_list)","def _get_invariom_list(self):\n self.invariom_list = []\n for molecule in self.values():\n for atom in molecule.atoms:\n for invariom in atom.invarioms:\n if not invariom in self.invariom_list:\n self.invariom_list.append(invariom)","def z_scan(self, z_position_list):\n self.generic_scan(self.z, z_position_list)","def count_sites_under_condition_vcf_to_set(vcf_file,chrom,start,end,mincov=0,maxcov=10000,inds=\"all\",bgzip=True,nb_ind_with_min_cov=\"all\",nalleles=[1,2],snps=False):\n\tset_ok_sites = set()\n\tinput_vcf=vcf.Reader(fsock=None, filename=vcf_file, compressed=bgzip, prepend_chr=\"False\", strict_whitespace=False)#open the vcf parser\n\tnsites_OK=0\n\tnsites_total=0\n\t#print \"in count_sites_under_condition_vcf nb_ind_with_min_cov :\",nb_ind_with_min_cov, \" inds\", ind\n\tif chrom!=\"all\":\n\t\t\t#print chrom,start,end\n\t\t\tcheck=len(sh.tabix(vcf_file,str(chrom)+\":\"+str(start)+\"-\"+str(end)))\n\t\t\t#print check\n\t\t\t#print \"check;' \",check,\"'\"\n\t\t\tif check==0: \n\t\t\t\treturn [0,0]\n\t\t\tfor record in input_vcf.fetch(chrom,start,end):# for every site\n\t\t\t\tcond=checkSnp_Cov(input_vcf,record,mincov,maxcov,inds=inds,nalleles=nalleles,nb_ind_with_min_cov=nb_ind_with_min_cov,snps=snps)# check if the site respect our condition\n\t\t\t\tnsites_total+=1\n\t\t\t\tif cond:# if it does\n\t\t\t\t\t#if any([int(sample['DP'])<5 for sample in record.samples]): print [int(sample['DP']) for sample in record.samples] # to check this argument nb_ind_with_min_cov\n\t\t\t\t\tset_ok_sites.add(str(record.CHROM)+\"_\"+str(record.POS))\n\treturn set_ok_sites","def getCaseDisp():\r\n liste = []\r\n for i in range(3):\r\n for j in range(3):\r\n if Grille[i][j] == 0:\r\n liste.append([i,j])\r\n return liste","def get_my_mutations(quality_cutoff, coverage_cutoff):\n\n # my_mutations = {}\n # with open('/home/perry/Projects/loh/working/murim.exome.aa_chg.vars') as f:\n # for line in f:\n # my_mutations[line.strip()] = True\n # return my_mutations\n\n bed_file = 'data/nimblegen/2.1M_Human_Exome_Annotation/2.1M_Human_Exome.bed'\n bed_chr2st2end, bed_chr2posLs = bed_tools.load_bed(bed_file, \n 'NimbleGen Tiled Regions')\n # NimbleGen Tiled Regions\n # Target Regions\n\n use_data_dir = '/home/perry/Projects/loh/data/all_non_ref_hg18/'\n all_somatic = {}\n all_inherited = {}\n cancer_qualities = mutations.get_consensus_qualities(use_data_dir + 'yusanT.ann')\n normal_qualities = mutations.get_consensus_qualities(use_data_dir + 'yusanN.ann')\n for exome in global_settings.exome_types:\n data_file = use_data_dir + exome\n inherited, somatic, murim = mutations.get_mutations(data_file, normal_qualities,\n cancer_qualities, quality_cutoff,\n False, coverage_cutoff)\n # only use the bed_tools NimbleGen\n # restriction for hg18 data\n for s in somatic['yusan']: \n chr, pos = s.split(':')\n if bed_tools.find_location_in_bed(chr, int(pos), \n bed_chr2posLs,\n bed_chr2st2end):\n all_somatic[s] = True\n for i in inherited['yusan']: \n chr, pos = s.split(':')\n if bed_tools.find_location_in_bed(chr, int(pos), \n bed_chr2posLs,\n bed_chr2st2end):\n all_inherited[i] = True\n return (set(all_somatic.keys()) & set(get_murim_covered(quality_cutoff)), set(all_inherited.keys()) & set(get_murim_covered(quality_cutoff)))","def getLigandResIds(ligchemid:str, struct: Structure)->List[Residue]:\n \"\"\"*ligchemids are of type https://www.rcsb.org/ligand/IDS\"\"\"\n ligandResidues: List[Residue] = list(filter(lambda x: x.get_resname() == ligchemid, list( struct.get_residues() )))\n return ligandResidues","def ifcs_subsets(me, ifcs):\n un = set()\n for i in ifcs:\n if i in me._ifc_subs:\n un.update(me._ifc_subs[i])\n return un","def __generate_streets(x_intercepts: list, y_intercepts: list) -> set:\n for x_start, x_end in zip(x_intercepts[:-1], x_intercepts[1:]):\n for y in y_intercepts:\n yield {(x, y) for x in range(x_start, x_end + 1)}\n for y_start, y_end in zip(y_intercepts[:-1], y_intercepts[1:]):\n for x in x_intercepts:\n yield {(x, y) for y in range(y_start, y_end + 1)}","def filter_to_candidate(self):\n filtered = { k: [] for k in self.annsets }\n for key, annset in self.annsets.items():\n for a in annset:\n if a.overlaps(self.candidate):\n filtered[key].append(a)\n self.annsets = filtered","def _getMdrizskyValues(self):\n mdict = {}\n mlist = []\n for member in self.assoc.parlist:\n fname = member['image'].datafile\n if not mdict.has_key(fname): \n mlist.append((fname, member['image'].getSubtractedSky()))\n mdict[fname] = 1\n \n return mlist","def exo3_2(mu,x0,n,m):\r\n S = []\r\n valeur = x0\r\n for i in range(0,n+1):\r\n valeur = exo2_1(valeur,mu)\r\n S.append(valeur)\r\n for i in range(m,n):\r\n valeur = exo2_1(valeur,mu)\r\n S.append(valeur)\r\n return S","def crime_list(loc:List[CrimeStatistics])->List[int]:\n # return [] #stub\n #template from List[CrimeStatistics]\n # crime_count is all the seperate university total crimes seen so far\n crime_count = [] #type: List[int]\n for cs in loc:\n crime_count.append(sum_crimes(cs))\n return crime_count","def mi_bin_ccd(x, y, z, bins):\n # get unique z elements\n z_u = np.unique(z)\n n_z = len(z_u)\n # compute mi for each elements of z\n pz = np.zeros((np.int64(n_z)), dtype=np.float32)\n icond = np.zeros((np.int64(n_z)), dtype=np.float32)\n for n_k, k in enumerate(z_u):\n idx_z = z == k\n pz[n_k] = idx_z.sum()\n _x, _y = x[idx_z], y[idx_z]\n icond[n_k] = mi_bin(_x, _y, bins, bins)\n # conditional mutual information\n pz /= len(z)\n cmi = np.sum(pz * icond)\n\n return cmi","def select_within_range(mags, colours, mag_min, mag_max, col_min, col_max):\n\n idx1 = np.where(colours >= col_min)[0]\n idx2 = np.where(colours <= col_max)[0]\n idx3 = np.where(mags >= mag_min)[0]\n idx4 = np.where(mags <= mag_max)[0]\n idx = set(idx1).intersection(set(idx2))\n idx = idx.intersection(set(idx3))\n idx = list(idx.intersection(set(idx4)))\n\n return idx","def test08(self):\n a = np.arange(1, 11)\n b = bcolz.carray(a)\n ul = [v for v in a if v <= 5]\n u = b.where(a <= 5)\n wl = [v for v in a if v <= 6]\n w = b.where(a <= 6)\n self.assertEqual(ul, list(u))\n self.assertEqual(wl, list(w))","def like(self, cname: str, mx: int = None)->list:\n res = self.data[self.data['cname'].str.contains(cname)].to_dict(orient='record')\n if not res: return []\n if (mx is not None) and (len(res) > mx):\n assert mx > 0, \"CountryCodes().like: `mx` argument must be positive or `None`.\"\n return res[:mx]\n return res","def Dominant_AZ(grsaz):\n\n M = {}\n RTs = list(set([y[1] for y in grsaz]))\n for rt in RTs:\n AZs = list(set([y[3] for y in grsaz if y[1] == rt]))\n MM = []\n for az in AZs:\n MM.append([az, sum([1 for y in grsaz if (y[1] == rt and y[3] == az)])])\n mini = min([m[0] for m in MM if m[1] == max([m[1] for m in MM])]) #we take the first AZ that has the maximal number of subnets\n M.update({rt: mini})\n return M","def zn_star(n):\n return [x for x in range(1, n) if coprime(x, n)]","def getClusterMembers(Z):\n\n clusters = {}\n for i, merge in enumerate(Z):\n cid = 1 + i + Z.shape[0]\n clusters[cid] = [merge[0], merge[1]]\n\n def _getIndices(clusters, i):\n if i <= Z.shape[0]:\n return [int(i)]\n else:\n return _getIndices(clusters, clusters[i][0]) + _getIndices(clusters, clusters[i][1])\n\n members = {i:_getIndices(clusters, i) for i in range(Z.shape[0] + 1, max(clusters.keys()) + 1)}\n return members","def get_complexes_with_abundance(self, query_abundance: int) -> List[KappaComplex]:\n result_complexes = []\n for complex_expression, complex_abundance in self._complexes.items():\n if query_abundance == complex_abundance:\n result_complexes.append(complex_expression)\n return result_complexes","def _as_set(self):\n included = set()\n excluded = set()\n # Add all points lying within each inclusion contour to S.\n for contour in self.contours:\n contour_matrix = contour.to_matrix()[:,:2]\n # Turn the contour closed if it's not.\n if (contour_matrix[0] != contour_matrix[-1]).all():\n contour_matrix = np.append(contour_matrix,\n contour_matrix[0].reshape(1,2),\n axis=0)\n\n # Create path object and test all pixels \n # within the contour's bounding box.\n path = mplpath.Path(contour_matrix, closed=True)\n mn = contour_matrix.min(axis=0)\n mx = contour_matrix.max(axis=0)\n x,y = np.mgrid[mn[0]:mx[0]+1, mn[1]:mx[1]+1]\n test_points = np.c_[x.flatten(), y.flatten()]\n points_in_contour = test_points[path.contains_points(test_points)]\n\n # Add the z coordinate.\n points_in_contour = np.c_[\\\n points_in_contour,\\\n np.ones(points_in_contour.shape[0])*contour.image_z_position\n ]\n\n # Now turn the numpy matrix into a list of tuples,\n # so we can add it to the corresponding set.\n points_in_contour = map(tuple, points_in_contour)\n\n # Update the corresponding set.\n if contour.inclusion:\n included.update(points_in_contour)\n else:\n excluded.update(points_in_contour)\n # Return the included points minus the excluded points.\n return included.difference( excluded )","def find_mgrs_intersection_100km(footprint, gzd_list):\n\n total_mgrs_100km_list = []\n\n for gzd in gzd_list:\n sub_list = find_mgrs_intersection_100km_single(footprint, gzd)\n for mgrs_id in sub_list:\n total_mgrs_100km_list.append(mgrs_id)\n\n return total_mgrs_100km_list","def test09(self):\n a = np.arange(10000) > 5000\n b = bcolz.carray(a, chunklen=100)\n b1 = b.wheretrue(skip=1020, limit=1020)\n b2 = b.wheretrue(skip=1030, limit=1020)\n a1 = a.nonzero()[0].tolist()[1020:2040]\n a2 = a.nonzero()[0].tolist()[1030:2050]\n # print \"result:\", [i for i in zip(b1, b2)]\n self.assertEqual([i for i in zip(a1, a2)], [i for i in zip(b1, b2)])","def addresses( data ) :\n return list( set(chain.from_iterable( [ re.sub(r'\\[.*?\\]\\s+','',x['C1']).split('; ') for x in data ] )))","def get_murim_mutations(quality_cutoff):\n\n os.system(\"grep somatic /home/perry/Projects/loh/data/murim/CANCER_specific.csv | cut -f 3,4,10 > /home/perry/Projects/loh/data/murim/somatic_coding_parsed_chr_pos_qual\")\n \n murim_mutations = {}\n with open('/home/perry/Projects/loh/data/murim/somatic_coding_parsed_chr_pos_qual') as f:\n for line in f:\n sp = line.strip().split('\\t')\n if float(sp[-1]) > float(quality_cutoff): # murim uses 80\n murim_mutations[sp[0] + ':' + sp[1]] = True\n remove_deletions(murim_mutations)\n return set(murim_mutations.keys()) & set(get_murim_covered(quality_cutoff))","def get_response_weights_vector(zenith,azimuth,binsize=5,cut=57.4):\n\n # assuming useful input:\n # azimuthal angle is periodic in the range [0,360[\n # zenith ranges from [0,180[ \n # checking azimuth range (can be exactly 360?)\n azimuth[azimuth == 360] -= 0.01\n \n # check which pixel (index) was hit on regular grid\n hit_pixel_zi = np.floor(zenith/binsize).astype(int)\n hit_pixel_ai = np.floor(azimuth/binsize).astype(int)\n\n # and which pixel centre\n hit_pixel_z = (hit_pixel_zi+0.5)*binsize\n hit_pixel_a = (hit_pixel_ai+0.5)*binsize\n\n # check which zeniths are beyond threshold\n bad_idx = np.where(hit_pixel_z > cut) \n \n # calculate nearest neighbour pixels indices\n za_idx = np.array([[np.floor(azimuth/binsize+0.5),np.floor(zenith/binsize+0.5)],\n [np.floor(azimuth/binsize+0.5),np.floor(zenith/binsize-0.5)],\n [np.floor(azimuth/binsize-0.5),np.floor(zenith/binsize+0.5)],\n [np.floor(azimuth/binsize-0.5),np.floor(zenith/binsize-0.5)]]).astype(int)\n\n # take care of bounds at zenith (azimuth is allowed to be -1!)\n (za_idx[:,1,:])[np.where(za_idx[:,1,:] < 0)] += 1\n (za_idx[:,1,:])[np.where(za_idx[:,1,:] >= 180/binsize)] = int(180/binsize-1)\n # but azimuth may not be larger than range [0,360/binsize[\n (za_idx[:,0,:])[np.where(za_idx[:,0,:] >= 360/binsize)] = 0\n \n # and pixel centres of neighbours\n azimuth_neighbours = (za_idx[:,0]+0.5)*binsize\n zenith_neighbours = (za_idx[:,1]+0.5)*binsize\n\n # calculate angular distances to neighbours\n dists = angular_distance(azimuth_neighbours,zenith_neighbours,azimuth,zenith)\n\n # inverse weighting to get impact of neighbouring pixels\n n_in = len(zenith)\n weights = (1/dists)/np.sum(1/dists,axis=0).repeat(4).reshape(n_in,4).T\n # if pixel is hit directly, set weight to 1.0\n weights[np.isnan(weights)] = 1\n # set beyond threshold weights to zero\n weights[:,bad_idx] = 0\n\n return za_idx,weights","def test02b(self):\n a = np.arange(1, 11)\n b = bcolz.carray(a)\n wt = [v for v in a if v <= 5 and v > 2]\n cwt = [v for v in b.where((a <= 5) & (a > 2))]\n # print \"numpy ->\", [v for v in a if v<=5 and v>2]\n # print \"where ->\", [v for v in b.where((a<=5) & (a>2))]\n self.assertTrue(wt == cwt, \"where() does not work correctly\")","def find_progenitors_until_z(self, mtree, nodeID, z1, z2):\n snapcount = 0\n print('from %d until %d' % (z2, z1))\n for ss in range(z2, z1, -1):\n if ss == z2:\n df_target = pd.DataFrame({'nodeID':nodeID})\n _indx = np.where(mtree.data.snapshotNumber.values == ss-1)\n nodeID_prog = mtree.data.index.values[_indx]\n nodeID_prog_desc = mtree.data.descendantIndex.values[_indx]\n _indx = np.where((nodeID_prog_desc < 1e15) &\n (nodeID_prog_desc > 1e11))\n nodeID_prog = nodeID_prog[_indx]\n nodeID_prog_desc = nodeID_prog_desc[_indx]\n\n df_prog = pd.DataFrame({'nodeID' : nodeID_prog,\n 'nodeID_target' : nodeID_prog_desc})\n\n # Initiliaze Output Array\n progcounts = np.zeros((df_target['nodeID'].size, z2-z1))\n\n # nodeID_prog_desc_unic is sorted\n nodeID_prog_desc_unic, count = np.unique(nodeID_prog_desc,\n return_counts=True)\n # remove -1's\n nodeID_prog_desc_unic=nodeID_prog_desc_unic[1:]; count=count[1:]\n\n # Nr. of progenitors for sub-&halos at snapshot z2\n s = pd.Index(df_target['nodeID'].tolist())\n _indx_now = s.get_indexer(list(nodeID_prog_desc_unic))\n now_sort_indx = np.argsort(df_target['nodeID'].values[_indx_now])\n pro_sort_indx = np.argsort(nodeID_prog_desc_unic)\n progcounts[_indx_now[now_sort_indx], snapcount] = count[pro_sort_indx]\n \n else:\n df_now = df_prog\n _indx = np.where(mtree.data.snapshotNumber.values == ss-1)\n nodeID_prog = mtree.data.index.values[_indx]\n nodeID_prog_desc = mtree.data.descendantIndex.values[_indx]\n #_indx = np.where((nodeID_prog_desc < 1e15) &\n # (nodeID_prog_desc > 1e10))\n #nodeID_prog = nodeID_prog[_indx]\n #nodeID_prog_desc = nodeID_prog_desc[_indx]\n df_prog = pd.DataFrame({'nodeID' : nodeID_prog})\n \n progcounts_local = np.zeros(df_now['nodeID'].size)\n nodeID_prog_desc_unic, count = np.unique(nodeID_prog_desc,\n return_counts=True)\n # remove -1's\n nodeID_prog_desc_unic=nodeID_prog_desc_unic[1:]; count=count[1:]\n \n # progenitors for snapshot ss\n s = pd.Index(df_now['nodeID'].tolist())\n _indx_now = s.get_indexer(list(nodeID_prog_desc_unic))\n now_sort_indx = np.argsort(df_now['nodeID'].values[_indx_now])\n pro_sort_indx = np.argsort(nodeID_prog_desc_unic)\n progcounts_local[_indx_now[now_sort_indx]] = count[pro_sort_indx]\n df_now['progcount'] = pd.Series(progcounts_local,\n index=df_now.index, dtype=int)\n\n # Nr. of progenitors for sub-&halos at snapshot z2\n df_inter = df_now.groupby(['nodeID_target'],\n as_index=False)['progcount'].sum()\n # only real progeniteurs\n df_inter = df_inter[(df_inter['nodeID_target'] > 1e10) & \n (df_inter['nodeID_target'] < 1e15)]\n df_inter = df_inter.drop_duplicates(subset=['nodeID_target'],\n keep='first')\n \n s = pd.Index(df_target['nodeID'].tolist())\n _indx_now = s.get_indexer(df_inter['nodeID_target'].tolist())\n now_sort_indx = np.argsort(df_target['nodeID'].values[_indx_now])\n pro_sort_indx = np.argsort(df_inter['nodeID_target'].values)\n progcounts[_indx_now[now_sort_indx], snapcount] = df_inter['progcount'].values[pro_sort_indx]\n\n # sort nodeID_prog to nodeID\n #s = pd.Index(df_now['nodeID'].tolist())\n #_indx_now = s.get_indexer(list(nodeID_prog_desc_unic))\n #df_now['nodeID_target'].values[_indx_now]\n \n obs_ref_local = np.zeros(df_prog['nodeID'].size)\n for ii in range(len(nodeID_prog_desc_unic)):\n tarID = df_now.loc[\n df_now['nodeID'] == nodeID_prog_desc_unic[ii],\n 'nodeID_target'].values.astype(int)\n if tarID:\n _indx = np.where(\n nodeID_prog_desc == nodeID_prog_desc_unic[ii])\n obs_ref_local[_indx] = tarID\n df_prog['nodeID_target'] = pd.Series(obs_ref_local,\n index=df_prog.index)\n\n snapcount += 1\n del nodeID_prog_desc\n del df_now, df_inter, df_prog\n return np.asarray(df_target['nodeID'].tolist()), progcounts","def test07(self):\n a = np.arange(10000)\n b = bcolz.carray(a,)\n wt = [v for v in a if v <= 5000][1010:2020]\n cwt = [v for v in b.where(bcolz.carray(a <= 5000, chunklen=100),\n limit=1010, skip=1010)]\n # print \"numpy ->\", [v for v in a if v>=5000][1010:2020]\n # print \"where ->\", [v for v in b.where(bcolz.carray(a>=5000,\n # chunklen=100),\n # limit=1010, skip=1010)]\n self.assertTrue(wt == cwt, \"where() does not work correctly\")","def filter_renters(data_df):\n return data_df[(data_df['sc116'] == 2) # Only renters\n & (data_df['uf17'] < 8000) # With a real rent provided\n ]"],"string":"[\n \"def get_subset_mz(self, mz):\\n regions = self.boxes_mz.at(mz)\\n it = BoxHolder()\\n for r in regions:\\n box = r.data\\n it.add_box(box)\\n return it\",\n \"def get_subset(mlist,year):\\n newlist = []\\n for entry in mlist:\\n if int(entry[0][:4]) > int(year):\\n continue\\n newvec = entry[:8]\\n citations = entry[8]['citations']\\n citations = filter(lambda a: int(a[:4]) <= int(year), citations)\\n newvec[2] = len(citations)\\n newlist.append(newvec)\\n return newlist\",\n \"def filter_pores_by_z(network, pores, z=1):\\n pores = network._parse_indices(pores)\\n Nz = network.num_neighbors(pores=pores)\\n orphans = np.where(Nz == z)[0]\\n hits = pores[orphans]\\n return hits\",\n \"def getLigandNbrs(resids: List[Residue], struct:Structure)->List[ResidueDict]:\\n\\n ns = NeighborSearch(list( struct.get_atoms() ))\\n nbrs = []\\n\\n for r in resids:\\n # a ligand consists of residues\\n resatoms = r.child_list[0]\\n # each residue has an atom plucked at random\\n for nbrresidues in ns.search(resatoms.get_coord(), 5,level='R'):\\n # we grab all residues in radius around that atom and extend the list of neighbors with those\\n nbrs.extend([nbrresidues])\\n\\n # Filter out the residues that constitute the ligand itself\\n filtered = [] \\n for neighbor in nbrs:\\n present = 0\\n for constit in resids:\\n if ResidueDict(constit)==ResidueDict( neighbor ):\\n present = 1\\n if present == 0:\\n filtered.append(ResidueDict(neighbor))\\n\\n return [ * map(lambda x: addBanClass(x) , set(filtered) ) ]\",\n \"def create_subsets(x, y):\\n # initiate empty list for return variables.\\n sets_x = []\\n sets_y = []\\n indices = []\\n\\n # iterate through value of PRI_JET_NUM (ranged inclusively from 0 until 3)\\n for pri_jet_num_val in np.unique(x[:,22]):\\n \\n # Find subset which DER_MASS_MMC is not equal to -999\\n mask = (x[:,22] == pri_jet_num_val) & (x[:,0] != -999)\\n x_tmp = x[mask,:]\\n y_tmp = y[mask]\\n\\n # store the subset into list\\n sets_x.append(x_tmp)\\n sets_y.append(y_tmp)\\n indices.append(mask)\\n\\n # Find subset which DER_MASS_MMC is equal to -999\\n mask = (x[:,22] == pri_jet_num_val) & (x[:,0] == -999)\\n x_tmp = x[mask,:]\\n y_tmp = y[mask]\\n\\n # store the subset into list\\n sets_x.append(x_tmp)\\n sets_y.append(y_tmp)\\n indices.append(mask) \\n \\n # return subsets of x, y, and corresponding indices\\n return sets_x, sets_y, indices\",\n \"def get_regions_mask(self, input):\",\n \"def _find_members(self, given_members):\\n if len(list(self.points)) > 3:\\n out_mem = [m for m in given_members if\\n self.intersects_poly(m.polygon)]\\n else:\\n out_mem = []\\n return out_mem\",\n \"def fetchCooler(c, regions, coolerFetch = lambda coo, ext:coo.matrix(balance=True, sparse=True).fetch(ext),\\n mask=True, force=False, ):\\n regions = [list(i) for i in regions]\\n resolution = c.binsize\\n\\n for i in regions:\\n if i[1] == None:\\n i[1] = 0 \\n if i[2] == None:\\n i[2] = c.chromsizes[i[0]]\\n\\n \\n for a in regions: \\n if str(a[0]) not in c.chromnames:\\n raise ValueError(\\\"Chromosome {0} from regions not found in cooler\\\".format(a))\\n if (a[1] % resolution) != 0:\\n raise ValueError(\\\"Start of an region should be a multiple fo resolution\\\")\\n \\n# bins = c.bins()[:]\\n \\n# # managing masks \\n# if mask is False: \\n# bins[\\\"mask\\\"] = 1 \\n# elif mask is None:\\n# assert \\\"mask\\\" in bins.columns\\n# elif mask is True: \\n# pass \\n# elif callable(mask):\\n# pass \\n# else:\\n# bins[\\\"mask\\\"] = mask \\n \\n \\n for region in regions:\\n matrix = coolerFetch(c, region)\\n try: # setting matrix nans to zeros.\\n matrix.data = np.nan_to_num(matrix.data, copy=False)\\n except TypeError: #workaround for old numpy versions\\n matrix.data = np.nan_to_num(matrix.data)\\n# st,end = c.extent(region)\\n# subbins = bins[st:end].copy()\\n if mask is True: \\n newmask = np.array((matrix.sum(axis=0) > 0 ))[0]\\n# if callable(mask):\\n# new_mask = mask(matrix)\\n# subbins[\\\"mask\\\"] = newmask \\n\\n assert len(newmask) == matrix.shape[0]\\n\\n yield matrix, newmask\",\n \"def get_relevant_zones(array,threshold=3):\\n\\n\\treturn [item for item in array if len(item)>3]\",\n \"def roi_vecs(layer_coords, vec_coords, region):\\n \\n if region == 'crown':\\n #find threshold for vectors inside roi\\n start_x_lst = []\\n stop_x_lst = []\\n for i in range(1,5):\\n start_x_lst.append(layer_coords[i][0][0])\\n stop_x_lst.append(layer_coords[i][-1][0])\\n\\n start_x = max(start_x_lst)\\n stop_x = min(stop_x_lst)\\n \\n roi_vec_coords = [i for i in vec_coords if i[0][0] in list(range(start_x, stop_x+5))]\\n \\n return roi_vec_coords\\n \\n elif region == 'fundus':\\n #find threshold for vectors inside roi\\n start_x_lst = []\\n stop_x_lst = []\\n for i in range(1,5):\\n start_x_lst.append(layer_coords[i][0][0])\\n stop_x_lst.append(layer_coords[i][-1][0])\\n\\n start_x = max(start_x_lst)\\n stop_x = min(stop_x_lst)\\n\\n # roi_vec_coords = [i for i in vec_coords if i[1][0] in list(range(start_x-10, stop_x+3))]\\n roi_vec_coords = [i for i in vec_coords if i[0][0] in list(range(stop_x, start_x))]\\n \\n # print(roi_vec_coords)\\n return roi_vec_coords\",\n \"def bounds(self, resids: NDArray) -> List[Tuple[float, float]]:\",\n \"def get_zones(array,kind,relevant=False,threshold=3):\\n\\n\\tresulting_set=[]\\n\\n\\ti=0\\n\\tif array[i]==kind:\\n\\t\\tcount=1\\n\\telse:\\n\\t\\tcount=0\\n\\n\\twhile i<len(array):\\n\\t\\t\\n\\t\\tif array[i]==kind:\\n\\t\\t\\tcount+=1\\n\\t\\telif array[i]!=kind and array[i-1]==kind:\\n\\t\\t\\tresulting_set.append(([kind]*count,i-count))\\n\\t\\t\\tcount=0\\n\\t\\telse:\\n\\t\\t\\tpass\\n\\n\\t\\ti+=1\\n\\n\\tif count>0:\\n\\t\\tresulting_set.append(([kind]*count, i-count))\\n\\n\\tif relevant == False:\\n\\t\\treturn resulting_set\\n\\telse:\\n\\t\\treturn [item for item in resulting_set if len(item[0])>threshold]\",\n \"def _get_ring_nodes(m, namin=3, namax=9, remove_redudant=T):\\n # first search for rings\\n sets = []\\n for i in range(namin, namax+1):\\n #if i in [3,4,5]:\\n pat_i = '*~1' + '~*'*(i-2) + '~*1'\\n #else:\\n # pat_i = '*:1' + ':*'*(i-2) + ':*1'\\n Qi = Chem.MolFromSmarts( pat_i )\\n for tsi in m.GetSubstructMatches(Qi):\\n set_i = set(tsi)\\n if set_i not in sets:\\n sets.append( set(tsi) )\\n if remove_redudant:\\n # now remove those rings that are union of smaller rings\\n n = len(sets)\\n sets_remove = []\\n ijs = itl.combinations( list(range(n)), 2 )\\n sets_u = []\\n for i,j in ijs:\\n set_ij = sets[i].union( sets[j] )\\n if (set_ij in sets) and (set_ij not in sets_remove):\\n sets_remove.append( set_ij )\\n sets_u = cim.get_compl(sets, sets_remove)\\n else:\\n sets_u = sets\\n return sets_u\",\n \"def get_feats(mz_list,intensity_list,feat_matrix,instance_index,feats,max_dist=275,allowed_c=[]):\\n\\t# UNCOMMENT var below if standard library combinations is used\\n\\t#allowed_c = set(allowed_c)\\n\\t\\n\\tspectrum = zip(mz_list,intensity_list)\\n\\tdists_mz = []\\n\\tdists_mz_intens = []\\n\\tprev_analyzed = set()\\n\\t\\n\\t#Make deepcopy since we are going to change the spectra!\\n\\tspec_one = copy.deepcopy(spectrum)\\n\\tspec_two = copy.deepcopy(spectrum)\\n\\t\\n\\t#Iterate over the peaks and measure the distance in m/z between all combinations\\n\\tfor peak_one in spec_one:\\n\\t\\tif len(spec_two) == 1: continue\\n\\t\\tspec_two = spec_two[1:]\\n\\t\\tfor peak_two in spec_two:\\n\\t\\t\\tdist_mz = abs(peak_one[0]-peak_two[0])\\n\\t\\t\\tif dist_mz > max_dist: break\\n\\t\\t\\tdists_mz.append(dist_mz)\\n\\t\\t\\tdists_mz_intens.append(peak_one[1]+peak_two[1])\\n\\t\\n\\t# UNCOMMENT code below if standard library combinations is used\\n\\t#for c in combinations(spectrum,2):\\n\\t#\\tdist_mz = abs(c[0][0]-c[1][0])\\n\\t#\\tif c[0][0] in prev_analyzed: continue\\n\\t#\\tif dist_mz > max_dist: \\n\\t#\\t\\tprev_analyzed.add(c[0][0])\\n\\t#\\t\\tcontinue\\n\\t#\\tif len(allowed_c) != 0:\\n\\t#\\t\\tif dist_mz not in allowed_c: continue\\n\\t#\\tdists_mz.append(dist_mz)\\n\\t#\\tdists_mz_intens.append(c[0][1]+c[1][1])\\n\\t\\n\\t#Digitize the delta m/z; assign bins for all delta m/z s\\n\\tindex_bins = np.digitize(dists_mz,feats)\\n\\t\\n\\t#Iterate over assigned bins and sum the intensity for possible existing values\\n\\tfor index,intens in zip(index_bins,dists_mz_intens):\\n\\t\\tfeat_matrix[instance_index,index-1] += intens\\n\\n\\treturn(feat_matrix)\",\n \"def get_data(n):\\n data = pd.read_csv('map_data/lior_results_2.csv')\\n data = data.drop(['estimated_mass', 'estimated_pop'], axis=1)\\n data = data[data.binomial != 'Sus scrofa'] # Wild Boar\\n data = data[data.binomial != 'Ursus maritimus'] # Polar bear\\n data = data[data.binomial != 'Sus bucculentus'] # EX\\n data = data[data.binomial != 'Melomys rubicola'] # EX\\n data = data.assign(total_mass=data.AdultBodyMassG * data.pop_density * data.Range,\\n total_mass_density=data.AdultBodyMassG * data.pop_density)\\n data = data.sort_values(by='total_mass_density', ascending=False)\\n data = data.iloc[0:n - 1]\\n geo_data = gpd.read_file('TERRESTRIAL_MAMMALS/TERRESTRIAL_MAMMALS.shp').to_crs(\\\"EPSG:6933\\\")\\n geo_data = geo_data[geo_data.category != 'EX']\\n range_polygons = geo_data.loc[(geo_data['legend'] == 'Extant & Introduced (resident)') |\\n (geo_data['legend'] == 'Extant & Origin Uncertain (resident)') |\\n (geo_data['legend'] == 'Extant & Reintroduced (resident)') |\\n (geo_data['legend'] == 'Extant & Vagrant (seasonality uncertain)') |\\n (geo_data['legend'] == 'Extant (non breeding)') |\\n (geo_data['legend'] == 'Extant (resident)') |\\n (geo_data['legend'] == 'Probably Extant & Origin Uncertain (resident)') |\\n (geo_data['legend'] == 'Probably Extant (resident)') |\\n (geo_data['legend'] == 'Reintroduced')]\\n range_polygons = range_polygons.merge(data, on='binomial')\\n range_polygons = range_polygons.to_crs(\\\"EPSG:6933\\\")\\n return range_polygons\",\n \"def items():\\n for i in self._iter_restrict(zeros, ones):\\n yield self.pcdata[i]\",\n \"def check_point(self, mz, rt):\\n regions = self.boxes_mz.at(mz)\\n hits = set()\\n for r in regions:\\n if r.data.rt_match(rt):\\n hits.add(r.data)\\n return hits\",\n \"def get_carboxyl_map(atom_list):\\n carboxyl_map = [[atom_list[x], atom_list[x+1], atom_list[x+2], atom_list[x+3]] for x in range(len(atom_list)-3) if ((atom_list[x].residue_name == atom_list[x+1].residue_name == atom_list[x+2].residue_name == atom_list[x+3].residue_name == \\\"C1A\\\") and (atom_list[x].residue_number == atom_list[x+1].residue_number == atom_list[x+2].residue_number == atom_list[x+3].residue_number) and (atom_list[x].atom_name != \\\"CY\\\" != atom_list[x+1].atom_name != atom_list[x+2].atom_name != \\\"CY\\\" != atom_list[x+3].atom_name ))]\\n return carboxyl_map\",\n \"def filter_residues(residues, biomolecule='PROTEIN'):\\n biomolecule = biomolecule.strip().upper()\\n standard_residues = []\\n for res in residues:\\n if res.get_resname().strip() in STANDARD_RESIDUES[biomolecule]:\\n if not res.id[0].strip(): standard_residues.append(res) # filter out hetro residues\\n return standard_residues\",\n \"def get_obstList(self,X,Y,Z):\\n\\n x = np.array(X); y = np.array(Y); z = np.array(Z);\\n dist = (x - self.x_c)**2 + (y - self.y_c)**2 + (z - self.z_c)**2\\n \\n return list(np.where(dist < self.r**2))\",\n \"def get_obstList(self,X,Y,Z):\\n\\n x = np.array(X); y = np.array(Y); z = np.array(Z);\\n dist = (x - self.x_c)**2 + (y - self.y_c)**2 + (z - self.z_c)**2\\n \\n return list(np.where(dist < self.r**2))\",\n \"def select_regions(binary,f,min=0,nbest=100000):\\n if binary.max() == 1:\\n labels,_ = label(binary)\\n else:\\n labels = binary.astype(uint8)\\n objects = find_objects(labels)\\n scores = [f(o) for o in objects]\\n best = argsort(scores)\\n keep = zeros(len(objects)+1,'i')\\n if nbest > 0:\\n for i in best[-nbest:]:\\n if scores[i]<=min: continue\\n keep[i+1] = 1\\n # print scores,best[-nbest:],keep\\n # print sorted(list(set(labels.ravel())))\\n # print sorted(list(set(keep[labels].ravel())))\\n return keep[labels]\",\n \"def findSubsetIndices(grdMODEL, min_lat, max_lat, min_lon, max_lon):\\n\\n\\n if min_lon<0 and max_lon>0:\\n splitExtract = True; Turns=2\\n grdMODEL.splitExtract=splitExtract\\n else:\\n splitExtract = False; Turns=1\\n grdMODEL.splitExtract=splitExtract\\n grdMODEL.lon = np.where(grdMODEL.lon>180,grdMODEL.lon-360,grdMODEL.lon)\\n \\n # Array to store the results returned from the function\\n res=np.zeros((Turns,4),dtype=np.float64)\\n \\n lats=grdMODEL.lat[:,0]\\n lons=grdMODEL.lon[0,:]\\n\\n \\n for k in range(Turns):\\n\\n if k==0 and splitExtract == True:\\n minLon=min_lon; maxLon=0\\n minLon=minLon+360\\n maxLon=maxLon+360\\n elif k==1 and splitExtract == True:\\n minLon=0; maxLon=max_lon\\n else:\\n minLon=min_lon; maxLon=max_lon\\n \\n distances1 = []\\n distances2 = []\\n indices=[]\\n index=1\\n for point in lats:\\n s1 = max_lat-point # (vector subtract)\\n s2 = min_lat-point # (vector subtract)\\n distances1.append((np.dot(s1, s1), point, index))\\n distances2.append((np.dot(s2, s2), point, index-1))\\n index=index+1\\n\\n distances1.sort()\\n distances2.sort()\\n indices.append(distances1[0])\\n indices.append(distances2[0])\\n \\n distances1 = []\\n distances2 = []\\n index=1\\n \\n for point in lons:\\n s1 = maxLon-point # (vector subtract)\\n s2 = minLon-point # (vector subtract)\\n distances1.append((np.dot(s1, s1), point, index))\\n distances2.append((np.dot(s2, s2), point, index-1))\\n index=index+1\\n \\n distances1.sort()\\n distances2.sort()\\n indices.append(distances1[0])\\n indices.append(distances2[0])\\n\\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\\n minJ=indices[1][2]\\n maxJ=indices[0][2]\\n minI=indices[3][2]\\n maxI=indices[2][2]\\n \\n res[k,0]=minI; res[k,1]=maxI; res[k,2]=minJ; res[k,3]=maxJ;\\n\\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\\n grdMODEL.indices=res\",\n \"def extract_upstream_for_meme(genomes, locuses, upstream, radius, overlap):\\n\\n records = []\\n for genome in genomes:\\n feature_len = len(genome.features)\\n\\n index = 0\\n locations = set()\\n for feature in filter(lambda f: f.type == \\\"CDS\\\", genome.features):\\n locus = feature.qualifiers[\\\"locus_tag\\\"][0] \\n if locus in locuses:\\n locations.add(index)\\n for i in range(index - radius, index + radius):\\n locations.add(i)\\n \\n index += 1\\n\\n print(locations)\\n records += extract_upstream(locations, genome, upstream, overlap)\\n\\n return records\",\n \"def getratios(results_condition,conditions):\\n setlist = {}\\n for r in range(conditions):\\n setlist[r] = []\\n \\n for gene in results_condition.genelist:\\n conditions = len(gene.logfold)\\n\\n count = 0\\n for set_ in setlist:\\n if gene.logfold[count] > 1.5 or gene.logfold[count] < -1.5 :\\n setlist[count].append(gene.name)\\n count +=1\\n return setlist\",\n \"def extract_pi_region(vcf_file,chrom,start,end,mincov=0,maxcov=10000,inds=\\\"all\\\",bgzip=True,min_nsites=0,min_variants=0,verbose=\\\"min\\\",called=True,output=\\\"pi\\\"):\\n\\tinput_vcf=vcf.Reader(fsock=None, filename=vcf_file, compressed=bgzip, prepend_chr=\\\"False\\\", strict_whitespace=False)#open the vcf parser\\n\\tif inds==\\\"all\\\" or inds==[\\\"all\\\"]:inds=input_vcf.samples# transform \\\"all\\\" in a list of all individuals in the vcf\\n\\t#Function\\n\\tpi_values=[]#list \\n\\tnsites_considered=0#iterator for sampling frequency\\n\\ttotal_nsites=0\\n\\tnvariants=0# iterator for sites that are varying\\n\\t###identify individual to remove when calculating stats\\n\\tinds_to_delete=[]\\n\\tfor i,ind in enumerate(input_vcf.samples):#check which ind is ion sample and compare it to our list of inds\\n\\t\\t if ind not in inds:#delete this ind\\n\\t\\t \\tinds_to_delete.append(i)\\n\\t#go along the region\\n\\tif chrom!=\\\"all\\\":\\n\\t\\tfor record in input_vcf.fetch(chrom,start,end):# for every site\\n\\t\\t\\tcond=checkRecord_Cov(input_vcf,record,mincov,maxcov,inds=inds,called=True,nalleles=[1,2])# check if the site respect our condition\\n\\t\\t\\ttotal_nsites+=1\\n\\t\\t\\tif cond:# if it does\\n\\t\\t\\t\\tnsites_considered+=1 \\n\\t\\t\\t \\tif total_nsites%100000==0: print total_nsites,\\\"sites\\\",nsites_considered,\\\"sites passed filter\\\"\\n\\t\\t\\t \\tfor index in sorted(inds_to_delete)[::-1]:#remove the individuals we do not want\\n\\t\\t\\t \\t\\tdel record.samples[index]\\n\\t\\t\\t \\tif verbose==True:print record.POS\\n\\t\\t\\t \\tif verbose==True:print \\\"inds\\\",inds\\t\\t \\t\\n\\t\\t\\t \\tif verbose==True:print \\\"GT\\\",[sample[\\\"GT\\\"] for sample in record.samples] \\n\\t\\t\\t \\tif verbose==True:print \\\"DP\\\",[sample[\\\"DP\\\"] for sample in record.samples]\\n\\t\\t\\t\\tpi_values.append(record.nucl_diversity)#calculate pi\\n\\t\\t\\t\\tif record.nucl_diversity>0.0:nvariants+=1\\n\\t\\t\\t#compute total information for the window\\n\\telif chrom==\\\"all\\\":\\n\\t\\tfor record in input_vcf:# for every site\\n\\t\\t\\tcond=checkRecord_Cov(input_vcf,record,mincov,maxcov,inds=inds,called=True,nalleles=[1,2])# check if the site respect our condition\\n\\t\\t\\ttotal_nsites+=1\\n\\t\\t\\tif cond:# if it does\\n\\t\\t\\t\\tnsites_considered+=1\\n\\t\\t\\t \\tif total_nsites%100000==0: print total_nsites,\\\"sites\\\",nsites_considered,\\\"sites passed filter\\\"\\n\\t\\t\\t \\tfor index in sorted(inds_to_delete)[::-1]:#remove the individuals we do not want\\n\\t\\t\\t \\t\\tdel record.samples[index]\\n\\t\\t\\t \\tif verbose==True:print record.POS\\n\\t\\t\\t \\tif verbose==True:print \\\"inds\\\",inds\\t\\t \\t\\n\\t\\t\\t \\tif verbose==True:print \\\"GT\\\",[sample[\\\"GT\\\"] for sample in record.samples] \\n\\t\\t\\t \\tif verbose==True:print \\\"DP\\\",[sample[\\\"DP\\\"] for sample in record.samples]\\n\\t\\t\\t\\tpi_values.append(record.nucl_diversity)#calculate pi\\n\\t\\t\\t\\tif record.nucl_diversity>0.0:nvariants+=1\\n\\tif verbose==True or verbose==\\\"min\\\":print \\\"nvariants:\\\",nvariants,\\\"nsites_considered:\\\",nsites_considered\\n\\tif output==\\\"pi\\\":\\n\\t\\tif nsites_considered>=min_nsites and nvariants>=min_variants and len(pi_values):\\n\\t\\t\\tpi_value=sum(pi_values)/nsites_considered\\t\\t\\n\\t\\t\\treturn pi_value\\n\\t\\telse:\\n\\t\\t\\treturn \\\"NA\\\"\\n\\telif output==\\\"extended\\\":\\n\\t\\tif nsites_considered>=min_nsites and nvariants>=min_variants and len(pi_values):\\n\\t\\t\\tpi_value=sum(pi_values)/nsites_considered\\t\\t\\n\\t\\t\\treturn [nvariants,nsites_considered,pi_value]\\n\\t\\telse:\\n\\t\\t\\treturn [nvariants,nsites_considered,\\\"NA\\\"]\\n\\telse:\\n\\t\\traise Exception(\\\"incorrect output argumnent, should be pi or extended\\\")\",\n \"def getIndexes(z_nummers):\\n sortCriteria = util.get_prop(\\\"ixsm\\\")\\n if not sortCriteria:\\n sortCriteria = \\\"z_index\\\"\\n sortCriteria = \\\"ORDER BY z_nummer, %s\\\" % sortCriteria\\n return getRecordsByAttributeIn(\\\"zeichnung\\\", \\\"z_nummer\\\", z_nummers, addtl=sortCriteria)\",\n \"def find_own_objects(cs):\\n own_objects = {}\\n for con in cs:\\n own_objects[con] = []\\n for obj in con.extent:\\n own_objects[con].append(obj)\\n for sub_con in cs:\\n if sub_con.extent < con.extent and\\\\\\n obj in sub_con.extent:\\n own_objects[con].pop()\\n break\\n return own_objects\",\n \"def find_progenitors_at_z(self, SH, mtree, z1, z2):\\n \\n for ss in range(z1, z2):\\n # nodes at redshift ss\\n ss_indx = np.where(mtree.data.snapshotNumber.values == ss)\\n nodeID = mtree.data.index.values[ss_indx]\\n nodeID_desc = mtree.data.descendantIndex.values[ss_indx]\\n \\n # find number of progenitors for nodes at redshift ss\\n if ss != z1:\\n _progcounts = np.zeros(len(nodeID))\\n for ii in range(len(nodeID_past_desc)):\\n if nodeID_past_desc[ii] in nodeID:\\n indx = np.where(nodeID == nodeID_past_desc[ii])\\n _progcounts[indx] = count[ii]\\n\\n nodeID_desc_unique, count = np.unique(nodeID_desc, return_counts=True)\\n nodeID_desc_unique=nodeID_desc_unique[1:]; count=count[1:]\\n \\n nodeID_past = nodeID\\n nodeID_past_desc = nodeID_desc_unique\\n if ss != z1:\\n _progcounts_past = _progcounts\\n print('_progcounts', _progcounts)\",\n \"def find_nearby_membranes(all_membranes, all_membrane_map, vert_normals):\\r\\n membrane_tree = scipy.spatial.cKDTree(all_membranes)\\r\\n nearby_membranes = np.array(list(membrane_tree.query_pairs(adhesion_max_dist, p=2)))\\r\\n nearby_membrane_map = defaultdict(list)\\r\\n if nearby_membranes.shape[0] > 0:\\r\\n # Exclude same-cell membrane interactions and same-direction-facing segments\\r\\n all_vert_normals = np.concatenate(vert_normals, axis=0)\\r\\n subset = np.where(\\r\\n (all_membrane_map[nearby_membranes[:, 0], 0] !=\\r\\n all_membrane_map[nearby_membranes[:, 1], 0])\\r\\n & (np.einsum('ij,ik->i', all_vert_normals[nearby_membranes[:, 0]], all_vert_normals[nearby_membranes[:, 1]]) < 0.0)\\r\\n )\\r\\n nearby_membranes = nearby_membranes[subset]\\r\\n # {cell idx: (vert idx, other cell idx, other vert idx, 'all_membranes' vert idx)}\\r\\n for nm in nearby_membranes:\\r\\n m0 = all_membrane_map[nm[0]]\\r\\n m1 = all_membrane_map[nm[1]]\\r\\n nearby_membrane_map[m0[0]].append((m0[1], m1[0], m1[1], nm[1]))\\r\\n nearby_membrane_map[m1[0]].append((m1[1], m0[0], m0[1], nm[0]))\\r\\n nearby_membrane_map = {k: np.array(v)\\r\\n for k, v in nearby_membrane_map.items()}\\r\\n# print(nearby_membrane_map)\\r\\n return nearby_membranes, nearby_membrane_map\",\n \"def xz_plane(blkmap, y):\\n result = []\\n base = y*blkmap.plane_span\\n z = 0\\n while z < blkmap.plane_span:\\n start = base + z\\n z += blkmap.row_span\\n end = base + z\\n result.append(tuple(blkmap.blocks[start:end]))\\n\\n return result\",\n \"def get_z_ranges(self):\\n\\n summary = self.get_rasters_summary()\\n\\n # Convert to dict in format:\\n # { 'stat' : { 'z': (min, max), ... } ... }\\n\\n ranges = summary.groupby(['stat', 'z'], as_index=False)\\n ranges = ranges.agg({'min': 'min', 'max': 'max'})\\n ranges['vals'] = ranges.apply(\\n lambda row: {\\n row['z']: (row['min'], row['max'])\\n }, axis=1)\\n ranges = ranges.groupby('stat')['vals'].apply(\\n lambda group: group.values)\\n ranges = ranges.apply(\\n lambda group: {\\n int(k): v for d in group for k,\\n v in d.items()})\\n\\n return ranges.to_dict()\",\n \"def pixelise_region(coordinates, shapefile):\\n return [coordinate for coordinate in coordinates if\\n (np.sum(shapefile['geometry'].apply(lambda x: Point(coordinate[1], coordinate[0]).within(x))) != 0) |\\n (np.sum(shapefile['geometry'].apply(lambda x: Point(coordinate[3], coordinate[0]).within(x))) != 0) |\\n (np.sum(shapefile['geometry'].apply(lambda x: Point(coordinate[1], coordinate[2]).within(x))) != 0) |\\n (np.sum(shapefile['geometry'].apply(lambda x: Point(coordinate[3], coordinate[2]).within(x))) != 0)]\",\n \"def __iteratively_retain(\\n self,\\n orf_regions: List[Tuple[int, int]]) -> List[Tuple[int, int]]:\\n\\n ret = []\\n\\n arr = np.zeros((len(self.seq), ))\\n\\n for start, end in orf_regions:\\n ret.append((start, end))\\n arr[start-1:end] = 1\\n orf_coverage = np.sum(arr) / len(arr)\\n if orf_coverage > self.min_orf_coverage:\\n break\\n\\n return ret\",\n \"def get_subregions(xint,conn):\\n\\n subregions = ('SELECT DISTINCT cvt.name, fip.value, f.name '\\n 'FROM interaction i, feature_interaction fi, feature_interactionprop fip, ' \\n 'feature f, cvterm cvt, cvterm cvt2, feature_relationship fr, feature f2 '\\n 'WHERE f.feature_id = fi.feature_id AND fi.interaction_id = i.interaction_id '\\n 'AND fi.feature_interaction_id = fip.feature_interaction_id '\\n 'AND fi.role_id = cvt.cvterm_id '\\n 'AND fip.type_id = cvt2.cvterm_id AND '\\n 'cvt2.name = \\\\'subpart_info\\\\' AND f.feature_id = fr.subject_id '\\n 'AND f2.feature_id = fr.object_id AND f.is_obsolete = \\\\'f\\\\' AND '\\n 'f2.uniquename = %s AND i.uniquename = %s')\\n subs = connect(subregions,xint,conn)\\n return(subs)\",\n \"def findlines(z,bgsub=True,SATURATED=57000.):\\n z = z.copy()\\n s = z.copy()\\n\\n \\\"\\\"\\\" First identify peaks. \\\"\\\"\\\"\\n max = ndimage.maximum_filter(z,9)\\n p = scipy.where((max==z)&(z<SATURATED)&(max>0))[0]\\n s = z[p]\\n\\n \\\"\\\"\\\" Reject low peaks. \\\"\\\"\\\"\\n bg = ndimage.percentile_filter(s,10,21)\\n peaks = scipy.where(s>bg*5.)[0]\\n return p[peaks]\",\n \"def get_protein_from_mz(self, mz, ppm=None, match_name=\\\"name\\\", data_slot=\\\"mzWeight\\\"):\\n\\n possibleMatches = []\\n\\n ppmDist = self.get_ppm(mz, ppm)\\n overlaps = self.mz_tree.overlap(mz-ppmDist, mz+ppmDist)\\n for overlap in overlaps:\\n \\n protMass = overlap[2][data_slot]\\n protDist = abs(mz-protMass)\\n \\n for name in overlap[2][match_name]:\\n possibleMatches.append((name, protMass, protDist))\\n\\n possibleMatches = sorted(possibleMatches, key=lambda x: x[2])\\n possibleMatches = [(x[0], x[1]) for x in possibleMatches]\\n\\n return possibleMatches\",\n \"def test_subset_reconstruction_iterable(self, wires):\\n circuit = hadamard_circuit(wires)\\n bits, recipes = circuit()\\n shadow = ClassicalShadow(bits, recipes)\\n\\n # choose 1000 random indices\\n snapshots = np.random.choice(np.arange(10000, dtype=np.int64), size=1000, replace=False)\\n state = shadow.global_snapshots(snapshots=snapshots)\\n assert state.shape == (len(snapshots), 2**wires, 2**wires)\\n\\n # check the results against obtaining the full global snapshots\\n expected = shadow.global_snapshots()\\n for i, t in enumerate(snapshots):\\n assert np.allclose(expected[t], state[i])\",\n \"def filtered_xyz(self) -> tuple[int, int, int]:\",\n \"def non_mcnugget():\\n nugget = [0, 6, 9, 20]\\n mcnugget = set([6, 9, 20])\\n\\n while True:\\n mcnugget = set([m+n for m in mcnugget for n in nugget])\\n\\n for m in mcnugget:\\n found = all([m+j in mcnugget for j in range(6)])\\n if found:\\n return [k for k in range(1, m) if k not in mcnugget]\",\n \"def select_regions(data, region_col, regions, combine_subregions=True):\",\n \"def get_points_in_range(self, x, y, z):\\n\\n return_set = []\\n for point in self.get_points():\\n min_x = x - 1000\\n max_x = x + 1000\\n if point[0] < min_x or max_x < point[0]:\\n continue\\n\\n min_y = y - 1000\\n max_y = y + 1000\\n if point[1] < min_y or max_y < point[1]:\\n continue\\n\\n min_z = z - 1000\\n max_z = z + 1000\\n if point[2] < min_z or max_z < point[2]:\\n continue\\n return_set.append(point)\\n return return_set\",\n \"def extract_region_curvilinear(cube, lat_bounds):\\n\\n cube = cube.copy() \\n \\n region_mask = create_region_mask(cube.coord('latitude').points, cube.shape, lat_bounds)\\n land_ocean_mask = cube.data.mask\\n complete_mask = region_mask + land_ocean_mask\\n\\n cube.data = numpy.ma.asarray(cube.data)\\n cube.data.mask = complete_mask\\n\\n return cube\",\n \"def defaulter(arr):\\n return list(set(map(lambda application: application['customer_id'], filter(lambda application: application['repaid_amount'] < (application['principal'] + application['fee']), arr))))\",\n \"def all_xs(tran_flag=None):\\n xs_ofinterest = {}\\n if tran_flag == 'tran':\\n xs_ofinterest[\\\"r\\\"] = ['abso', 'fiss', 'nufi',\\n 'spec', 'tran', 'ener', 'difc', 'tota', 'excs']\\n if tran_flag == 'tranXYZ':\\n xs_ofinterest[\\\"r\\\"] = ['abso', 'fiss', 'nufi', 'spec', 'ener', 'difc', 'tota', 'excs',\\n 'tran121', 'tran221', 'tran011', 'tran311', 'tran012', 'tran112', 'tran122', 'tran322', 'tran321', 'tran212', 'tran211', 'tran312', 'tran111', 'tran222', 'tran021', 'tran022']\\n xs_ofinterest[\\\"g\\\"] = ['1', '2']\\n\\n return xs_ofinterest\",\n \"def test08(self):\\n a = np.arange(10000) > 5000\\n b = bcolz.carray(a, chunklen=100)\\n u = b.wheretrue(skip=1020, limit=1020)\\n w = b.wheretrue(skip=1030, limit=1030)\\n self.assertEqual(a.nonzero()[0].tolist()[1020:2040], list(u))\\n self.assertEqual(a.nonzero()[0].tolist()[1030:2060], list(w))\",\n \"def afindwithin(data):\\r\\n numfact = len(data[0])-2\\r\\n withinvec = [0]*numfact\\r\\n for col in range(1,numfact+1):\\r\\n rows = pstats.linexand(data,col,pstats.unique(pstats.colex(data,1))[0]) # get 1 level of this factor\\r\\n if len(pstats.unique(pstats.colex(rows,0))) < len(rows): # if fewer subjects than scores on this factor\\r\\n withinvec[col-1] = 1\\r\\n return withinvec\",\n \"def get_obstList(self,X,Y,Z):\\n \\n x_c_cone = self.x_c\\n\\tz_c_cone = self.z_c\\n y_c_cone = 0\\n x_s = 2.25*2*self.cyl_rad\\n rad_cone = x_s + self.cyl_rad\\n\\th_cone = rad_cone*0.57735\\n\\n floor_part = np.array(np.where(Y < h_cone)).flatten()\\n\\n dist = (X - self.x_c)**2 + (Z - self.z_c)**2;\\n cyl_part = list(np.array(np.where( dist < self.cyl_rad**2)).flatten())\\n\\n scour_pit = np.array(np.where( (X - x_c_cone)**2 + (Z - z_c_cone)**2 <= ((self.cyl_rad/cone)/(h_cone))**2*(Y - y_c_cone)**2))\\n\\n # remove the scour pit from the floor\\n obst_list = np.setxor1d(floor_part[:], \\n np.intersect1d(floor_part[:],scour_pit[:]))\\n\\n\\n # then add the cylinder\\n obst_list = np.union1d(obst_list[:],cyl_part[:])\\n \\n return list(obst_list[:])\",\n \"def get_uv_coverage(Nbase, z, ncells, boxsize=None):\\n\\tif not boxsize: boxsize = c2t.conv.LB\\n\\tuv_map = np.zeros((ncells,ncells))\\n\\ttheta_max = c2t.conv.LB/c2t.z_to_cdist(z)\\n\\tfor p in xrange(Nbase.shape[0]):\\n\\t\\ti,j,k = np.round(Nbase[p,0]*theta_max),np.round(Nbase[p,1]*theta_max),np.round(Nbase[p,2]*theta_max)\\n\\t\\tif np.abs(i)<ncells:\\n\\t\\t\\tif np.abs(j)<ncells:\\n\\t\\t\\t\\tuv_map[int(i),int(j)] += 1\\n\\treturn uv_map\",\n \"def create_city_map(n: int) -> set:\\n return set((row, col) for row in range(0, n) for col in range(0, n))\",\n \"def C(v,securite):\\n to_return = set()\\n x,y = l[v][0],l[v][1]\\n a,b = id_case(x,y) #on recupere la case ou se trouve le disque qu'on test\\n voisinage = set(cases[a,b]) #on recupere la liste du voisinage (pas forcement contact)\\n #4\\n #012\\n #345\\n #678 \\n if a>100:\\n voisinage = add_list(voisinage,cases[a-4*rayon,b]) #3\\n if b>200:\\n voisinage = add_list(voisinage,cases[a-4*rayon,b-4*rayon]) #0\\n voisinage = add_list(voisinage,cases[a,b-4*rayon]) #1\\n if b<600:\\n voisinage = add_list(voisinage,cases[a-4*rayon,b+4*rayon]) #6\\n voisinage = add_list(voisinage,cases[a,b+4*rayon]) #7\\n if a<1100-4*rayon:\\n voisinage = add_list(voisinage,cases[a+4*rayon,b]) #5\\n if b>200:\\n voisinage = add_list(voisinage,cases[a+4*rayon,b-4*rayon]) #2\\n voisinage = add_list(voisinage,cases[a,b-4*rayon]) #1\\n if b<600:\\n voisinage = add_list(voisinage,cases[a+4*rayon,b+4*rayon]) #8\\n voisinage = add_list(voisinage,cases[a,b+4*rayon]) #7\\n \\n #On ajoute plusieurs fois le meme a un ensemble -> pas grave\\n for i in voisinage:\\n xb,yb = l[i][0],l[i][1]\\n if 0<sqrt((x-xb)**2+(y-yb)**2)<=2*rayon+securite:\\n to_return.add(i)\\n return to_return\",\n \"def test10(self):\\n a = np.arange(1, 11)\\n b = bcolz.carray(a)\\n bi = b.where(a <= 5)\\n ai = (v for v in a if v <= 5)\\n self.assertEqual([i for i in ai], [i for i in bi])\\n self.assertEqual([i for i in ai], [i for i in bi])\",\n \"def _setup_all_residues(self, model_num=0):\\n all_residues = vector1()\\n\\n for chain_id in self.get_chain_ids(model_num):\\n #print \\\"ChainID: \\\"+chain_id\\n residues = self.residues(chain_id, model_num)\\n all_residues.extend(residues)\\n\\n return all_residues\",\n \"def find_unique_elements(molecule_map):\\n atoms = []\\n for molec_name in molecule_map.keys():\\n atoms += [subst['atom'] for subst in molecule_map[molec_name]]\\n return set(atoms)\",\n \"def filter(self, rois):\\n can_fragments = np.array([roi.can_fragment for roi in rois])\\n return can_fragments\",\n \"def zmembers(self):\\n return self.zrange(0, -1)\",\n \"def match_regions(self):\\n l = []\\n for r1 in self.regions_names():\\n for r2 in self.metric.index:\\n r11 = r1.replace('-', ' ').lower()\\n r22 = r2.replace('-', ' ').lower()\\n l.append([r1,r2,fuzz.ratio(r11, r22)])\\n\\n matched = np.array([x for x in l if x[2] > 80])\\n\\n return {key: value for (key, value) in matched[:,[1,0]]}\",\n \"def extractstates(self, bias=1.0):\\n items = []\\n print(\\\"weights:\\\")\\n print([round(comp.weight, 7) for comp in self.gmm])\\n for comp in self.gmm:\\n val = comp.weight * float(bias)\\n if val > 0.5:\\n for _ in range(int(round(val))):\\n items.append(deepcopy(comp.loc))\\n for x in items: print(x.T)\\n return items\",\n \"def gen_mass_spec(self, mz_lst, bin_num=20000):\\n # m2z is from [MZ_MIN, MZ_MAX], with bin_num bins. Note its length is len(hist) + 1\\n # intensity: counts from samples in that bin.\\n self.intensity, self.m2z = np.histogram(mz_lst, bins=bin_num, range=(MZ_MIN, MZ_MAX))\",\n \"def mask_range(b, z, lam_em, lam_cent):\\n dz = 2. * b * np.sqrt(np.log(2.)) / c\\n del_lam = lam_cent * dz\\n return lam_cent - del_lam, lam_cent + del_lam\",\n \"def segregate(primers: list):\\n\\n group1 = list(filter(lambda primer: 53 <= primer.tm < 58, primers))\\n group2 = list(filter(lambda primer: 58 <= primer.tm <= 62, primers))\\n\\n return group1, group2\",\n \"def residues(ls):\\n # List residue atom index to be restrained\\n res_atom_set = set()\\n\\n # Dictionary of lists with the chain residues selected to be restrained\\n # e.g. {chainA:[res1, res15], chainB:[res19, res17]}\\n chain_dic = {'': []}\\n\\n # Fill out the chain dictionary\\n i = 0\\n while i < len(ls):\\n if ls[i].isdigit():\\n chain_dic[''].append(int(ls[i]))\\n i += 1\\n else:\\n try:\\n chain_dic[ls[i]].append(int(ls[i + 2]))\\n except:\\n chain_dic[ls[i]] = []\\n chain_dic[ls[i]].append(int(ls[i + 2]))\\n i += 3\\n\\n # Loop over the molecular system to select the atom indexes to be selected\\n hv = oechem.OEHierView(system, oechem.OEAssumption_BondedResidue + oechem.OEAssumption_ResPerceived)\\n for chain in hv.GetChains():\\n chain_id = chain.GetChainID()\\n if chain_id not in chain_dic:\\n continue\\n for frag in chain.GetFragments():\\n for hres in frag.GetResidues():\\n res_num = hres.GetOEResidue().GetResidueNumber()\\n if res_num not in chain_dic[chain_id]:\\n continue\\n for oe_at in hres.GetAtoms():\\n res_atom_set.add(oe_at.GetIdx())\\n\\n return res_atom_set\",\n \"def dummy_nms(list_maps, prob, parent_idx, scores):# slice_idx=0):\\n rval = []\\n for slice_idx, maps in zip(parent_idx, list_maps):\\n for s in maps:\\n # Apply the filter based on proba\\n maps[s] = maps[s] * (maps[s] > prob - scores[slice_idx])\\n n_z = np.transpose(np.nonzero(maps[s]))\\n rval.extend([[s,\\n n_z[e, 0], n_z[e, 1],\\n maps[s][n_z[e, 0], n_z[e, 1]],\\n slice_idx]\\n for e in range(len(n_z))])\\n #print 'nb of nonzero patches :', len(rval)\\n if rval != []:\\n rval.sort(key=lambda x: x[3], reverse=True)\\n #print 'min :', min(rval, key=lambda x: x[3])\\n #print'max :', max(rval, key=lambda x: x[3])\\n return rval\",\n \"def cfdGetOwnersSubArrayForBoundaryPatch(self):\\r\\n \\r\\n for iBPatch, theBCInfo in self.cfdBoundaryPatchesArray.items():\\r\\n \\r\\n startBFace=self.cfdBoundaryPatchesArray[iBPatch]['startFaceIndex']\\r\\n \\r\\n endBFace=startBFace+self.cfdBoundaryPatchesArray[iBPatch]['numberOfBFaces']\\r\\n \\r\\n iBFaces=list(range(int(startBFace),int(endBFace))) \\r\\n \\r\\n self.cfdBoundaryPatchesArray[iBPatch]['owners_b']=[self.owners[i] for i in iBFaces]\",\n \"def get_all_bandgaps(cluster, spin_list, dir=\\\"/home/pv278/Platinum/\\\"):\\n E, s = [], []\\n for spin in spin_list:\\n Ebg = get_bandgap(cluster, spin, dir)\\n if Ebg:\\n E.append(Ebg)\\n s.append(spin)\\n return np.vstack((s,E)).T\",\n \"def slice_zvals(self):\\n return np.sort([z.val for z in self.zvals])\",\n \"def all_subconstituents(self, compute=False):\\n out = {}\\n for i in range(self._.d+1):\\n try:\\n out[i] = self.subconstituent(i, compute=compute)\\n except IndexError:\\n pass\\n return out\",\n \"def find_features_geojson(self, geojson_tagset):\\n kreis_region_bund_list = []\\n only_regs_set = set()\\n for feature in geojson_tagset:\\n bundesl = feature.properties.get('NAME_1')\\n region = feature.properties.get('NAME_2')\\n kreis = feature.properties.get('NAME_3')\\n\\n kreis_region_bund_list.append((kreis, region, bundesl))\\n #Check: does \\\"Göttingen\\\" appear in this list as a region? Why does Goettingen need to be a region?)\\n return kreis_region_bund_list\",\n \"def subdata(min_,dict_):\\n list_ = []\\n return [value for value,freq in dict_.items() if freq > min_]\",\n \"def get_element_indices_within_rectangle(self, xmin, xmax, zmin, zmax):\\n centroids = self.get_element_centroids()\\n indices_list = []\\n for nr, (x, z) in enumerate(centroids):\\n if x >= xmin and x <= xmax and z >= zmin and z <= zmax:\\n indices_list.append(nr)\\n return np.array(indices_list)\",\n \"def _get_invariom_list(self):\\n self.invariom_list = []\\n for molecule in self.values():\\n for atom in molecule.atoms:\\n for invariom in atom.invarioms:\\n if not invariom in self.invariom_list:\\n self.invariom_list.append(invariom)\",\n \"def z_scan(self, z_position_list):\\n self.generic_scan(self.z, z_position_list)\",\n \"def count_sites_under_condition_vcf_to_set(vcf_file,chrom,start,end,mincov=0,maxcov=10000,inds=\\\"all\\\",bgzip=True,nb_ind_with_min_cov=\\\"all\\\",nalleles=[1,2],snps=False):\\n\\tset_ok_sites = set()\\n\\tinput_vcf=vcf.Reader(fsock=None, filename=vcf_file, compressed=bgzip, prepend_chr=\\\"False\\\", strict_whitespace=False)#open the vcf parser\\n\\tnsites_OK=0\\n\\tnsites_total=0\\n\\t#print \\\"in count_sites_under_condition_vcf nb_ind_with_min_cov :\\\",nb_ind_with_min_cov, \\\" inds\\\", ind\\n\\tif chrom!=\\\"all\\\":\\n\\t\\t\\t#print chrom,start,end\\n\\t\\t\\tcheck=len(sh.tabix(vcf_file,str(chrom)+\\\":\\\"+str(start)+\\\"-\\\"+str(end)))\\n\\t\\t\\t#print check\\n\\t\\t\\t#print \\\"check;' \\\",check,\\\"'\\\"\\n\\t\\t\\tif check==0: \\n\\t\\t\\t\\treturn [0,0]\\n\\t\\t\\tfor record in input_vcf.fetch(chrom,start,end):# for every site\\n\\t\\t\\t\\tcond=checkSnp_Cov(input_vcf,record,mincov,maxcov,inds=inds,nalleles=nalleles,nb_ind_with_min_cov=nb_ind_with_min_cov,snps=snps)# check if the site respect our condition\\n\\t\\t\\t\\tnsites_total+=1\\n\\t\\t\\t\\tif cond:# if it does\\n\\t\\t\\t\\t\\t#if any([int(sample['DP'])<5 for sample in record.samples]): print [int(sample['DP']) for sample in record.samples] # to check this argument nb_ind_with_min_cov\\n\\t\\t\\t\\t\\tset_ok_sites.add(str(record.CHROM)+\\\"_\\\"+str(record.POS))\\n\\treturn set_ok_sites\",\n \"def getCaseDisp():\\r\\n liste = []\\r\\n for i in range(3):\\r\\n for j in range(3):\\r\\n if Grille[i][j] == 0:\\r\\n liste.append([i,j])\\r\\n return liste\",\n \"def get_my_mutations(quality_cutoff, coverage_cutoff):\\n\\n # my_mutations = {}\\n # with open('/home/perry/Projects/loh/working/murim.exome.aa_chg.vars') as f:\\n # for line in f:\\n # my_mutations[line.strip()] = True\\n # return my_mutations\\n\\n bed_file = 'data/nimblegen/2.1M_Human_Exome_Annotation/2.1M_Human_Exome.bed'\\n bed_chr2st2end, bed_chr2posLs = bed_tools.load_bed(bed_file, \\n 'NimbleGen Tiled Regions')\\n # NimbleGen Tiled Regions\\n # Target Regions\\n\\n use_data_dir = '/home/perry/Projects/loh/data/all_non_ref_hg18/'\\n all_somatic = {}\\n all_inherited = {}\\n cancer_qualities = mutations.get_consensus_qualities(use_data_dir + 'yusanT.ann')\\n normal_qualities = mutations.get_consensus_qualities(use_data_dir + 'yusanN.ann')\\n for exome in global_settings.exome_types:\\n data_file = use_data_dir + exome\\n inherited, somatic, murim = mutations.get_mutations(data_file, normal_qualities,\\n cancer_qualities, quality_cutoff,\\n False, coverage_cutoff)\\n # only use the bed_tools NimbleGen\\n # restriction for hg18 data\\n for s in somatic['yusan']: \\n chr, pos = s.split(':')\\n if bed_tools.find_location_in_bed(chr, int(pos), \\n bed_chr2posLs,\\n bed_chr2st2end):\\n all_somatic[s] = True\\n for i in inherited['yusan']: \\n chr, pos = s.split(':')\\n if bed_tools.find_location_in_bed(chr, int(pos), \\n bed_chr2posLs,\\n bed_chr2st2end):\\n all_inherited[i] = True\\n return (set(all_somatic.keys()) & set(get_murim_covered(quality_cutoff)), set(all_inherited.keys()) & set(get_murim_covered(quality_cutoff)))\",\n \"def getLigandResIds(ligchemid:str, struct: Structure)->List[Residue]:\\n \\\"\\\"\\\"*ligchemids are of type https://www.rcsb.org/ligand/IDS\\\"\\\"\\\"\\n ligandResidues: List[Residue] = list(filter(lambda x: x.get_resname() == ligchemid, list( struct.get_residues() )))\\n return ligandResidues\",\n \"def ifcs_subsets(me, ifcs):\\n un = set()\\n for i in ifcs:\\n if i in me._ifc_subs:\\n un.update(me._ifc_subs[i])\\n return un\",\n \"def __generate_streets(x_intercepts: list, y_intercepts: list) -> set:\\n for x_start, x_end in zip(x_intercepts[:-1], x_intercepts[1:]):\\n for y in y_intercepts:\\n yield {(x, y) for x in range(x_start, x_end + 1)}\\n for y_start, y_end in zip(y_intercepts[:-1], y_intercepts[1:]):\\n for x in x_intercepts:\\n yield {(x, y) for y in range(y_start, y_end + 1)}\",\n \"def filter_to_candidate(self):\\n filtered = { k: [] for k in self.annsets }\\n for key, annset in self.annsets.items():\\n for a in annset:\\n if a.overlaps(self.candidate):\\n filtered[key].append(a)\\n self.annsets = filtered\",\n \"def _getMdrizskyValues(self):\\n mdict = {}\\n mlist = []\\n for member in self.assoc.parlist:\\n fname = member['image'].datafile\\n if not mdict.has_key(fname): \\n mlist.append((fname, member['image'].getSubtractedSky()))\\n mdict[fname] = 1\\n \\n return mlist\",\n \"def exo3_2(mu,x0,n,m):\\r\\n S = []\\r\\n valeur = x0\\r\\n for i in range(0,n+1):\\r\\n valeur = exo2_1(valeur,mu)\\r\\n S.append(valeur)\\r\\n for i in range(m,n):\\r\\n valeur = exo2_1(valeur,mu)\\r\\n S.append(valeur)\\r\\n return S\",\n \"def crime_list(loc:List[CrimeStatistics])->List[int]:\\n # return [] #stub\\n #template from List[CrimeStatistics]\\n # crime_count is all the seperate university total crimes seen so far\\n crime_count = [] #type: List[int]\\n for cs in loc:\\n crime_count.append(sum_crimes(cs))\\n return crime_count\",\n \"def mi_bin_ccd(x, y, z, bins):\\n # get unique z elements\\n z_u = np.unique(z)\\n n_z = len(z_u)\\n # compute mi for each elements of z\\n pz = np.zeros((np.int64(n_z)), dtype=np.float32)\\n icond = np.zeros((np.int64(n_z)), dtype=np.float32)\\n for n_k, k in enumerate(z_u):\\n idx_z = z == k\\n pz[n_k] = idx_z.sum()\\n _x, _y = x[idx_z], y[idx_z]\\n icond[n_k] = mi_bin(_x, _y, bins, bins)\\n # conditional mutual information\\n pz /= len(z)\\n cmi = np.sum(pz * icond)\\n\\n return cmi\",\n \"def select_within_range(mags, colours, mag_min, mag_max, col_min, col_max):\\n\\n idx1 = np.where(colours >= col_min)[0]\\n idx2 = np.where(colours <= col_max)[0]\\n idx3 = np.where(mags >= mag_min)[0]\\n idx4 = np.where(mags <= mag_max)[0]\\n idx = set(idx1).intersection(set(idx2))\\n idx = idx.intersection(set(idx3))\\n idx = list(idx.intersection(set(idx4)))\\n\\n return idx\",\n \"def test08(self):\\n a = np.arange(1, 11)\\n b = bcolz.carray(a)\\n ul = [v for v in a if v <= 5]\\n u = b.where(a <= 5)\\n wl = [v for v in a if v <= 6]\\n w = b.where(a <= 6)\\n self.assertEqual(ul, list(u))\\n self.assertEqual(wl, list(w))\",\n \"def like(self, cname: str, mx: int = None)->list:\\n res = self.data[self.data['cname'].str.contains(cname)].to_dict(orient='record')\\n if not res: return []\\n if (mx is not None) and (len(res) > mx):\\n assert mx > 0, \\\"CountryCodes().like: `mx` argument must be positive or `None`.\\\"\\n return res[:mx]\\n return res\",\n \"def Dominant_AZ(grsaz):\\n\\n M = {}\\n RTs = list(set([y[1] for y in grsaz]))\\n for rt in RTs:\\n AZs = list(set([y[3] for y in grsaz if y[1] == rt]))\\n MM = []\\n for az in AZs:\\n MM.append([az, sum([1 for y in grsaz if (y[1] == rt and y[3] == az)])])\\n mini = min([m[0] for m in MM if m[1] == max([m[1] for m in MM])]) #we take the first AZ that has the maximal number of subnets\\n M.update({rt: mini})\\n return M\",\n \"def zn_star(n):\\n return [x for x in range(1, n) if coprime(x, n)]\",\n \"def getClusterMembers(Z):\\n\\n clusters = {}\\n for i, merge in enumerate(Z):\\n cid = 1 + i + Z.shape[0]\\n clusters[cid] = [merge[0], merge[1]]\\n\\n def _getIndices(clusters, i):\\n if i <= Z.shape[0]:\\n return [int(i)]\\n else:\\n return _getIndices(clusters, clusters[i][0]) + _getIndices(clusters, clusters[i][1])\\n\\n members = {i:_getIndices(clusters, i) for i in range(Z.shape[0] + 1, max(clusters.keys()) + 1)}\\n return members\",\n \"def get_complexes_with_abundance(self, query_abundance: int) -> List[KappaComplex]:\\n result_complexes = []\\n for complex_expression, complex_abundance in self._complexes.items():\\n if query_abundance == complex_abundance:\\n result_complexes.append(complex_expression)\\n return result_complexes\",\n \"def _as_set(self):\\n included = set()\\n excluded = set()\\n # Add all points lying within each inclusion contour to S.\\n for contour in self.contours:\\n contour_matrix = contour.to_matrix()[:,:2]\\n # Turn the contour closed if it's not.\\n if (contour_matrix[0] != contour_matrix[-1]).all():\\n contour_matrix = np.append(contour_matrix,\\n contour_matrix[0].reshape(1,2),\\n axis=0)\\n\\n # Create path object and test all pixels \\n # within the contour's bounding box.\\n path = mplpath.Path(contour_matrix, closed=True)\\n mn = contour_matrix.min(axis=0)\\n mx = contour_matrix.max(axis=0)\\n x,y = np.mgrid[mn[0]:mx[0]+1, mn[1]:mx[1]+1]\\n test_points = np.c_[x.flatten(), y.flatten()]\\n points_in_contour = test_points[path.contains_points(test_points)]\\n\\n # Add the z coordinate.\\n points_in_contour = np.c_[\\\\\\n points_in_contour,\\\\\\n np.ones(points_in_contour.shape[0])*contour.image_z_position\\n ]\\n\\n # Now turn the numpy matrix into a list of tuples,\\n # so we can add it to the corresponding set.\\n points_in_contour = map(tuple, points_in_contour)\\n\\n # Update the corresponding set.\\n if contour.inclusion:\\n included.update(points_in_contour)\\n else:\\n excluded.update(points_in_contour)\\n # Return the included points minus the excluded points.\\n return included.difference( excluded )\",\n \"def find_mgrs_intersection_100km(footprint, gzd_list):\\n\\n total_mgrs_100km_list = []\\n\\n for gzd in gzd_list:\\n sub_list = find_mgrs_intersection_100km_single(footprint, gzd)\\n for mgrs_id in sub_list:\\n total_mgrs_100km_list.append(mgrs_id)\\n\\n return total_mgrs_100km_list\",\n \"def test09(self):\\n a = np.arange(10000) > 5000\\n b = bcolz.carray(a, chunklen=100)\\n b1 = b.wheretrue(skip=1020, limit=1020)\\n b2 = b.wheretrue(skip=1030, limit=1020)\\n a1 = a.nonzero()[0].tolist()[1020:2040]\\n a2 = a.nonzero()[0].tolist()[1030:2050]\\n # print \\\"result:\\\", [i for i in zip(b1, b2)]\\n self.assertEqual([i for i in zip(a1, a2)], [i for i in zip(b1, b2)])\",\n \"def addresses( data ) :\\n return list( set(chain.from_iterable( [ re.sub(r'\\\\[.*?\\\\]\\\\s+','',x['C1']).split('; ') for x in data ] )))\",\n \"def get_murim_mutations(quality_cutoff):\\n\\n os.system(\\\"grep somatic /home/perry/Projects/loh/data/murim/CANCER_specific.csv | cut -f 3,4,10 > /home/perry/Projects/loh/data/murim/somatic_coding_parsed_chr_pos_qual\\\")\\n \\n murim_mutations = {}\\n with open('/home/perry/Projects/loh/data/murim/somatic_coding_parsed_chr_pos_qual') as f:\\n for line in f:\\n sp = line.strip().split('\\\\t')\\n if float(sp[-1]) > float(quality_cutoff): # murim uses 80\\n murim_mutations[sp[0] + ':' + sp[1]] = True\\n remove_deletions(murim_mutations)\\n return set(murim_mutations.keys()) & set(get_murim_covered(quality_cutoff))\",\n \"def get_response_weights_vector(zenith,azimuth,binsize=5,cut=57.4):\\n\\n # assuming useful input:\\n # azimuthal angle is periodic in the range [0,360[\\n # zenith ranges from [0,180[ \\n # checking azimuth range (can be exactly 360?)\\n azimuth[azimuth == 360] -= 0.01\\n \\n # check which pixel (index) was hit on regular grid\\n hit_pixel_zi = np.floor(zenith/binsize).astype(int)\\n hit_pixel_ai = np.floor(azimuth/binsize).astype(int)\\n\\n # and which pixel centre\\n hit_pixel_z = (hit_pixel_zi+0.5)*binsize\\n hit_pixel_a = (hit_pixel_ai+0.5)*binsize\\n\\n # check which zeniths are beyond threshold\\n bad_idx = np.where(hit_pixel_z > cut) \\n \\n # calculate nearest neighbour pixels indices\\n za_idx = np.array([[np.floor(azimuth/binsize+0.5),np.floor(zenith/binsize+0.5)],\\n [np.floor(azimuth/binsize+0.5),np.floor(zenith/binsize-0.5)],\\n [np.floor(azimuth/binsize-0.5),np.floor(zenith/binsize+0.5)],\\n [np.floor(azimuth/binsize-0.5),np.floor(zenith/binsize-0.5)]]).astype(int)\\n\\n # take care of bounds at zenith (azimuth is allowed to be -1!)\\n (za_idx[:,1,:])[np.where(za_idx[:,1,:] < 0)] += 1\\n (za_idx[:,1,:])[np.where(za_idx[:,1,:] >= 180/binsize)] = int(180/binsize-1)\\n # but azimuth may not be larger than range [0,360/binsize[\\n (za_idx[:,0,:])[np.where(za_idx[:,0,:] >= 360/binsize)] = 0\\n \\n # and pixel centres of neighbours\\n azimuth_neighbours = (za_idx[:,0]+0.5)*binsize\\n zenith_neighbours = (za_idx[:,1]+0.5)*binsize\\n\\n # calculate angular distances to neighbours\\n dists = angular_distance(azimuth_neighbours,zenith_neighbours,azimuth,zenith)\\n\\n # inverse weighting to get impact of neighbouring pixels\\n n_in = len(zenith)\\n weights = (1/dists)/np.sum(1/dists,axis=0).repeat(4).reshape(n_in,4).T\\n # if pixel is hit directly, set weight to 1.0\\n weights[np.isnan(weights)] = 1\\n # set beyond threshold weights to zero\\n weights[:,bad_idx] = 0\\n\\n return za_idx,weights\",\n \"def test02b(self):\\n a = np.arange(1, 11)\\n b = bcolz.carray(a)\\n wt = [v for v in a if v <= 5 and v > 2]\\n cwt = [v for v in b.where((a <= 5) & (a > 2))]\\n # print \\\"numpy ->\\\", [v for v in a if v<=5 and v>2]\\n # print \\\"where ->\\\", [v for v in b.where((a<=5) & (a>2))]\\n self.assertTrue(wt == cwt, \\\"where() does not work correctly\\\")\",\n \"def find_progenitors_until_z(self, mtree, nodeID, z1, z2):\\n snapcount = 0\\n print('from %d until %d' % (z2, z1))\\n for ss in range(z2, z1, -1):\\n if ss == z2:\\n df_target = pd.DataFrame({'nodeID':nodeID})\\n _indx = np.where(mtree.data.snapshotNumber.values == ss-1)\\n nodeID_prog = mtree.data.index.values[_indx]\\n nodeID_prog_desc = mtree.data.descendantIndex.values[_indx]\\n _indx = np.where((nodeID_prog_desc < 1e15) &\\n (nodeID_prog_desc > 1e11))\\n nodeID_prog = nodeID_prog[_indx]\\n nodeID_prog_desc = nodeID_prog_desc[_indx]\\n\\n df_prog = pd.DataFrame({'nodeID' : nodeID_prog,\\n 'nodeID_target' : nodeID_prog_desc})\\n\\n # Initiliaze Output Array\\n progcounts = np.zeros((df_target['nodeID'].size, z2-z1))\\n\\n # nodeID_prog_desc_unic is sorted\\n nodeID_prog_desc_unic, count = np.unique(nodeID_prog_desc,\\n return_counts=True)\\n # remove -1's\\n nodeID_prog_desc_unic=nodeID_prog_desc_unic[1:]; count=count[1:]\\n\\n # Nr. of progenitors for sub-&halos at snapshot z2\\n s = pd.Index(df_target['nodeID'].tolist())\\n _indx_now = s.get_indexer(list(nodeID_prog_desc_unic))\\n now_sort_indx = np.argsort(df_target['nodeID'].values[_indx_now])\\n pro_sort_indx = np.argsort(nodeID_prog_desc_unic)\\n progcounts[_indx_now[now_sort_indx], snapcount] = count[pro_sort_indx]\\n \\n else:\\n df_now = df_prog\\n _indx = np.where(mtree.data.snapshotNumber.values == ss-1)\\n nodeID_prog = mtree.data.index.values[_indx]\\n nodeID_prog_desc = mtree.data.descendantIndex.values[_indx]\\n #_indx = np.where((nodeID_prog_desc < 1e15) &\\n # (nodeID_prog_desc > 1e10))\\n #nodeID_prog = nodeID_prog[_indx]\\n #nodeID_prog_desc = nodeID_prog_desc[_indx]\\n df_prog = pd.DataFrame({'nodeID' : nodeID_prog})\\n \\n progcounts_local = np.zeros(df_now['nodeID'].size)\\n nodeID_prog_desc_unic, count = np.unique(nodeID_prog_desc,\\n return_counts=True)\\n # remove -1's\\n nodeID_prog_desc_unic=nodeID_prog_desc_unic[1:]; count=count[1:]\\n \\n # progenitors for snapshot ss\\n s = pd.Index(df_now['nodeID'].tolist())\\n _indx_now = s.get_indexer(list(nodeID_prog_desc_unic))\\n now_sort_indx = np.argsort(df_now['nodeID'].values[_indx_now])\\n pro_sort_indx = np.argsort(nodeID_prog_desc_unic)\\n progcounts_local[_indx_now[now_sort_indx]] = count[pro_sort_indx]\\n df_now['progcount'] = pd.Series(progcounts_local,\\n index=df_now.index, dtype=int)\\n\\n # Nr. of progenitors for sub-&halos at snapshot z2\\n df_inter = df_now.groupby(['nodeID_target'],\\n as_index=False)['progcount'].sum()\\n # only real progeniteurs\\n df_inter = df_inter[(df_inter['nodeID_target'] > 1e10) & \\n (df_inter['nodeID_target'] < 1e15)]\\n df_inter = df_inter.drop_duplicates(subset=['nodeID_target'],\\n keep='first')\\n \\n s = pd.Index(df_target['nodeID'].tolist())\\n _indx_now = s.get_indexer(df_inter['nodeID_target'].tolist())\\n now_sort_indx = np.argsort(df_target['nodeID'].values[_indx_now])\\n pro_sort_indx = np.argsort(df_inter['nodeID_target'].values)\\n progcounts[_indx_now[now_sort_indx], snapcount] = df_inter['progcount'].values[pro_sort_indx]\\n\\n # sort nodeID_prog to nodeID\\n #s = pd.Index(df_now['nodeID'].tolist())\\n #_indx_now = s.get_indexer(list(nodeID_prog_desc_unic))\\n #df_now['nodeID_target'].values[_indx_now]\\n \\n obs_ref_local = np.zeros(df_prog['nodeID'].size)\\n for ii in range(len(nodeID_prog_desc_unic)):\\n tarID = df_now.loc[\\n df_now['nodeID'] == nodeID_prog_desc_unic[ii],\\n 'nodeID_target'].values.astype(int)\\n if tarID:\\n _indx = np.where(\\n nodeID_prog_desc == nodeID_prog_desc_unic[ii])\\n obs_ref_local[_indx] = tarID\\n df_prog['nodeID_target'] = pd.Series(obs_ref_local,\\n index=df_prog.index)\\n\\n snapcount += 1\\n del nodeID_prog_desc\\n del df_now, df_inter, df_prog\\n return np.asarray(df_target['nodeID'].tolist()), progcounts\",\n \"def test07(self):\\n a = np.arange(10000)\\n b = bcolz.carray(a,)\\n wt = [v for v in a if v <= 5000][1010:2020]\\n cwt = [v for v in b.where(bcolz.carray(a <= 5000, chunklen=100),\\n limit=1010, skip=1010)]\\n # print \\\"numpy ->\\\", [v for v in a if v>=5000][1010:2020]\\n # print \\\"where ->\\\", [v for v in b.where(bcolz.carray(a>=5000,\\n # chunklen=100),\\n # limit=1010, skip=1010)]\\n self.assertTrue(wt == cwt, \\\"where() does not work correctly\\\")\",\n \"def filter_renters(data_df):\\n return data_df[(data_df['sc116'] == 2) # Only renters\\n & (data_df['uf17'] < 8000) # With a real rent provided\\n ]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5860528","0.5294917","0.5274569","0.5238881","0.51128125","0.50799537","0.50743914","0.4973342","0.49630117","0.49471557","0.49072868","0.48891437","0.48831913","0.48573068","0.48536083","0.4842539","0.4838259","0.48302126","0.48269477","0.48252738","0.48252738","0.47874793","0.47615215","0.47506213","0.4731234","0.4727928","0.47208488","0.47161487","0.47065267","0.47056028","0.46979076","0.46955457","0.4693687","0.46924844","0.46898326","0.46838233","0.46837205","0.46769276","0.46662793","0.46621603","0.46604034","0.46506578","0.46492493","0.46392006","0.46377832","0.46303982","0.46223432","0.46208256","0.46171883","0.461183","0.46106964","0.4602705","0.46026492","0.46024603","0.46015605","0.45938286","0.45937926","0.45919457","0.45864853","0.4585179","0.45850745","0.45837298","0.45785147","0.45742166","0.45734","0.45724922","0.4571986","0.4569257","0.4568298","0.4568218","0.45674047","0.45664465","0.4564145","0.45603573","0.45480317","0.4547539","0.45463285","0.45454586","0.45430183","0.454249","0.45398495","0.45383015","0.45340255","0.45236278","0.4521765","0.45210484","0.45202768","0.45197627","0.45094135","0.45062017","0.45028785","0.4500924","0.44992474","0.44968927","0.44958377","0.449549","0.4491847","0.44907","0.44828823","0.44805866"],"string":"[\n \"0.5860528\",\n \"0.5294917\",\n \"0.5274569\",\n \"0.5238881\",\n \"0.51128125\",\n \"0.50799537\",\n \"0.50743914\",\n \"0.4973342\",\n \"0.49630117\",\n \"0.49471557\",\n \"0.49072868\",\n \"0.48891437\",\n \"0.48831913\",\n \"0.48573068\",\n \"0.48536083\",\n \"0.4842539\",\n \"0.4838259\",\n \"0.48302126\",\n \"0.48269477\",\n \"0.48252738\",\n \"0.48252738\",\n \"0.47874793\",\n \"0.47615215\",\n \"0.47506213\",\n \"0.4731234\",\n \"0.4727928\",\n \"0.47208488\",\n \"0.47161487\",\n \"0.47065267\",\n \"0.47056028\",\n \"0.46979076\",\n \"0.46955457\",\n \"0.4693687\",\n \"0.46924844\",\n \"0.46898326\",\n \"0.46838233\",\n \"0.46837205\",\n \"0.46769276\",\n \"0.46662793\",\n \"0.46621603\",\n \"0.46604034\",\n \"0.46506578\",\n \"0.46492493\",\n \"0.46392006\",\n \"0.46377832\",\n \"0.46303982\",\n \"0.46223432\",\n \"0.46208256\",\n \"0.46171883\",\n \"0.461183\",\n \"0.46106964\",\n \"0.4602705\",\n \"0.46026492\",\n \"0.46024603\",\n \"0.46015605\",\n \"0.45938286\",\n \"0.45937926\",\n \"0.45919457\",\n \"0.45864853\",\n \"0.4585179\",\n \"0.45850745\",\n \"0.45837298\",\n \"0.45785147\",\n \"0.45742166\",\n \"0.45734\",\n \"0.45724922\",\n \"0.4571986\",\n \"0.4569257\",\n \"0.4568298\",\n \"0.4568218\",\n \"0.45674047\",\n \"0.45664465\",\n \"0.4564145\",\n \"0.45603573\",\n \"0.45480317\",\n \"0.4547539\",\n \"0.45463285\",\n \"0.45454586\",\n \"0.45430183\",\n \"0.454249\",\n \"0.45398495\",\n \"0.45383015\",\n \"0.45340255\",\n \"0.45236278\",\n \"0.4521765\",\n \"0.45210484\",\n \"0.45202768\",\n \"0.45197627\",\n \"0.45094135\",\n \"0.45062017\",\n \"0.45028785\",\n \"0.4500924\",\n \"0.44992474\",\n \"0.44968927\",\n \"0.44958377\",\n \"0.449549\",\n \"0.4491847\",\n \"0.44907\",\n \"0.44828823\",\n \"0.44805866\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.59874827"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":3,"numItemsPerPage":100,"numTotalItems":95772,"offset":300,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3MzUyMzQxMSwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3NzM1MjcwMTEsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.IS-VjO2vUDxfd3IMD5jsNKwl7CPkYdA5gNJq3DC5bG7MWTECdkiVeZshNflLLWZ6kQjc_r37vb1WTp7cWH_YDQ","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102 values |
|---|---|---|---|---|---|---|
Changes the priority of the element elem to prio. | def change_priority(self, elem, prio):
pos = self.pos[elem]
currPrio = self.A[pos][1]
self.A[pos] = (elem, prio)
if self.cmpFn(prio, currPrio):
self.insert_loop(pos, pos // 2) # Up heapify
else:
self.combine(pos) # Down heapify | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setPriority(self, p):\n self.priority = p",
"def _update_priority(self, task, prio, worker):\n task.priority = prio = max(prio, task.priority)\n for dep in task.deps or []:\n t = self._state.get_task(dep)\n if t is not None and prio > t.priority:\n self._... | [
"0.67719734",
"0.6752105",
"0.6318923",
"0.6283811",
"0.6121634",
"0.61172235",
"0.6071931",
"0.6042161",
"0.5969836",
"0.5969836",
"0.5969836",
"0.5935215",
"0.5908808",
"0.59068906",
"0.5899444",
"0.5884699",
"0.5880411",
"0.58484524",
"0.58209383",
"0.5818788",
"0.5729039"... | 0.81994 | 0 |
Gets the priority of an element. | def get_priority(self, elem):
pos = self.pos[elem]
return self.A[pos][1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getpriority(self, name):\n\t\tif name not in self:\n\t\t\treturn None\n\t\treturn self.attributes[name].priority",
"def _get_priority(self):\n return self.__priority",
"def _get_priority(self):\n return self.__priority",
"def _get_priority(self):\n return self.__priority",
"def _get_priority(s... | [
"0.7882315",
"0.7649342",
"0.7649342",
"0.7649342",
"0.7649342",
"0.7647876",
"0.7647876",
"0.7504323",
"0.74972016",
"0.7453977",
"0.74093306",
"0.74017596",
"0.73951834",
"0.73866266",
"0.7357312",
"0.7357312",
"0.7357312",
"0.72419477",
"0.72419477",
"0.72419477",
"0.72419... | 0.8585831 | 0 |
Gets the minimum element of the heap. | def min(self):
return self.get_first() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def findmin(self):\n return self.heap[0] if len(self.heap) > 0 else None",
"def min(self):\r\n if self._size == 0: raise KeyError # Nothing to return if heap empty\r\n return self._data[0] # so simple!\r",
"def get_min(self) -> object:\n if not self.is_empty():\n ... | [
"0.86202234",
"0.8542973",
"0.8532992",
"0.85131574",
"0.8460315",
"0.84360385",
"0.8252153",
"0.81792325",
"0.8092698",
"0.8078686",
"0.80421853",
"0.79581094",
"0.7663294",
"0.76157564",
"0.75814164",
"0.7493778",
"0.74732834",
"0.7461151",
"0.7447867",
"0.7397468",
"0.7345... | 0.7234268 | 26 |
Gets the minimum element of the heap and removes it. | def take_min(self):
return self.get_first() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_min(self):\r\n # Should raise an exception of size is 0...\r\n if self._size == 0: raise KeyError # Can't remove from an empty heap\r\n result = self._data[0] # remember the smallest\r\n self._data[0] = None # None is so we don't have a reference.\r\n ... | [
"0.8762053",
"0.8528082",
"0.85083675",
"0.8469478",
"0.83009934",
"0.82481664",
"0.8209636",
"0.81854427",
"0.8066061",
"0.80339926",
"0.80249083",
"0.7980516",
"0.788914",
"0.7866211",
"0.7851768",
"0.78122234",
"0.7769824",
"0.77424836",
"0.76917297",
"0.7681458",
"0.76671... | 0.0 | -1 |
Gets the maximum element of the heap. | def max(self):
return self.get_first() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def heap_extract_max(self, A):\n max = A[0]\n A[0] = A[len(A)-1]\n del A[-1] #use del so it stays out of the function\n self.max_heapify(A, 0)\n return max",
"def heap_pop_max(heap):\n last = heap.pop()\n if heap:\n return_item = heap[0]\n heap[0] = last\n ... | [
"0.7984895",
"0.79142934",
"0.77526826",
"0.75617915",
"0.75280285",
"0.7499288",
"0.74823093",
"0.74128735",
"0.7341171",
"0.73030984",
"0.7244219",
"0.7195734",
"0.71896243",
"0.7186615",
"0.71417284",
"0.71403116",
"0.71197176",
"0.71066064",
"0.7081008",
"0.70789945",
"0.... | 0.73672485 | 8 |
Gets the maximum element of the heap and removes it. | def take_max(self):
return self.delete_first() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_max(self):\n retval = self.heap_list[1]\n self.heap_list[1] = self.heap_list[self.size]\n self.size = self.size - 1\n pop_val = self.heap_list.pop()\n self.percolate_down(1)\n return retval",
"def remove(self):\n max_item = self.heaplist[1]\n sel... | [
"0.8782797",
"0.8520369",
"0.834615",
"0.80668986",
"0.79649794",
"0.77679366",
"0.77248996",
"0.76835424",
"0.7677773",
"0.7659807",
"0.76241404",
"0.7556659",
"0.75099057",
"0.75092083",
"0.74387366",
"0.74314845",
"0.73972696",
"0.7393631",
"0.7384405",
"0.7384216",
"0.737... | 0.6685935 | 61 |
Transcodes a file src to a file dest. | def transcode(self, src: Path, dest: Path) -> None:
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copyFile( src, dest ):\n\tinFile = open( src, 'r' )\n\toutFile = open( dest, 'w' )\n\tfor line in inFile:\n\t\toutFile.write( line )\n\toutFile.close()\n\tinFile.close()",
"def compressFile(source, target):\n data = cake.filesys.readFile(source)\n try:\n data = zlib.compress(data, 1)\n except zlib.erro... | [
"0.6751052",
"0.6534881",
"0.61683327",
"0.6163265",
"0.61372477",
"0.6119148",
"0.60524434",
"0.602882",
"0.598594",
"0.5982905",
"0.5955934",
"0.59134305",
"0.5866599",
"0.585062",
"0.58318645",
"0.5749547",
"0.5694051",
"0.56439036",
"0.5634352",
"0.5634352",
"0.5634352",
... | 0.7879794 | 0 |
Takes an integer below 1001 and converts it into english text. Ignore spaces and hyphens as the instructions require. | def int2text(integer):
# Numbers 1-99 are handled by simply looking up words in the special_case
# dictionary.
if integer < 100:
return digit2text(integer)
elif integer < 1000:
# If exactly some hundred, then just return the word for the hundred's
# place and the word 'hundred'
if integer%100 == 0:
return digit2text(integer/100)+'hundred'
# Otherwise return the word for the hundred's place, the word
# 'hundredand' and do some composition to make the rest of the words.
else:
return digit2text(integer/100)+'hundredand'+\
digit2text(integer%100)
# Special case for 1000.
elif integer == 1000:
return "onethousand" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def english(number):\r\n if number == 0:\r\n return 'zero'\r\n word = ''\r\n for step in itertools.count():\r\n number, rest = divmod(number, 1000)\r\n word = format_num(en3(rest), step) + word\r\n if number == 0:\r\n return word.strip()",
"def number2text(integer)... | [
"0.7711457",
"0.736089",
"0.6570956",
"0.65348077",
"0.6504594",
"0.6472066",
"0.6465786",
"0.6318002",
"0.63022107",
"0.6287715",
"0.6235496",
"0.6192539",
"0.61917514",
"0.6169387",
"0.6149354",
"0.6142758",
"0.61054987",
"0.60986495",
"0.60660845",
"0.60206014",
"0.5872346... | 0.7366785 | 1 |
Takes integer digits/double digits and returns the english text for these numbers. | def digit2text(integer):
# If the integer is in the special cases dictionary, then look up the word,
# return it, and we're done.
if integer in special_case_dict.keys():
return special_case_dict[integer]
# Otherwise compose the word, by taking the number in the ten's place and
# multiplying by 10 (i.e. integer/10*10 evaluates to a number in the set
# {10, 20, 30, 40, 50, 60, 70, 80, 90} for any input integer between 10-99.
# Then add word for the number in the one's place
else:
return special_case_dict[integer/10*10]+special_case_dict[integer%10] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def english(number):\r\n if number == 0:\r\n return 'zero'\r\n word = ''\r\n for step in itertools.count():\r\n number, rest = divmod(number, 1000)\r\n word = format_num(en3(rest), step) + word\r\n if number == 0:\r\n return word.strip()",
"def int2text(integer):\n... | [
"0.7694077",
"0.7104256",
"0.7084235",
"0.6613821",
"0.64341813",
"0.6333191",
"0.6266428",
"0.62469083",
"0.6115907",
"0.6083413",
"0.6064189",
"0.6041851",
"0.5971319",
"0.59671617",
"0.59606844",
"0.58907706",
"0.5845223",
"0.58414835",
"0.5818904",
"0.5810572",
"0.5807192... | 0.7075966 | 3 |
Solves [a]{b} = {x} by Gauss elimination. | def gaussElimin(a,b):
a=float64(a)
b=float64(b)
n=len(b)
x=zeros((n,1),dtype=float)
for k in range(n-1):
for i in range(k+1,n):
l=float(a[i][k])/a[k][k]
a[i][k]=0
for j in range(k+1,n):
a[i][j]=a[i][j]-l*a[k][j]
b[i]=b[i]-l*b[k]
x[n-1]=float(b[n-1])/a[n-1][n-1]
for i in range(n-2,-1,-1):
sum=b[i]
for j in range(i+1,n):
sum=sum-a[i][j]*x[j]
x[i]=float(sum)/a[i][i]
return x | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gaussian_elimination(A, b):\n \n m, n = A.shape\n U = A.copy() \n b = b.copy()\n\n # forward sweep, reduce A to a upper triangular matrix\n for k in range(min(m, n)):\n swap = np.argmax(np.abs(U[k:, k])) + k\n if U[swap, k] == 0:\n raise ValueError('Singular matrix')\... | [
"0.7353518",
"0.71408343",
"0.71251684",
"0.70046204",
"0.6569199",
"0.64925224",
"0.6439031",
"0.63340366",
"0.62848866",
"0.6225892",
"0.6141184",
"0.61222094",
"0.6090073",
"0.6016392",
"0.5969952",
"0.5954091",
"0.59377366",
"0.5927988",
"0.59233207",
"0.59059817",
"0.583... | 0.7767935 | 0 |
Solves [L][U]{x} = b, where [a] = [L\U] is the matrix returned from LUdecomp. | def LUsolve(a,b):
b=float64(b)
n=len(b)
LU=LUdecomp(a)
y=zeros((n,1))
x=zeros((n,1))
y[0]=b[0]
for i in range(1,n):
sum=b[i]
for j in range(i):
sum=sum-LU[i][j]*y[j]
y[i]=sum
x[n-1]=float(y[n-1])/LU[n-1][n-1]
for i in range(n-2,-1,-1):
sum=y[i]
for j in range(i+1,n):
sum=sum-LU[i][j]*x[j]
x[i]=float(sum)/LU[i][i]
return x | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def LU_solve(A, d, b):\n \n\n L, U = L1U(A, d)\n\n y = rforwardsolve(L, b, d)\n x = rbackwardsolve(U, y, d)\n\n return x",
"def lu_decom(A,b):\n # init\n n = len(b)\n L = np.eye(n)\n U = np.zeros((n,n))\n x = np.zeros(n)\n y = np.zeros(n)\n\n # decomposition A = LU\n\n U[0,... | [
"0.8204323",
"0.77781606",
"0.7435162",
"0.7326853",
"0.71451354",
"0.7074888",
"0.6962283",
"0.69174",
"0.6882864",
"0.6877735",
"0.68558407",
"0.6839501",
"0.67079276",
"0.6632435",
"0.6581103",
"0.6516492",
"0.6455007",
"0.63229835",
"0.62904537",
"0.62402534",
"0.6206865"... | 0.79200137 | 1 |
Starting offset of the segment | def start(self):
return self.start_ | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start_offset(self):\n return self.get_info_value(\"D_STARTOFFS\")",
"def offset_from_start(self, part):\n index = self.parts.index(part)\n return sum([p.length for p in self.parts[:index]])",
"def min_offset(self):\n return self.offset",
"def offset_segment(self, i):\n ... | [
"0.75695366",
"0.7171375",
"0.7162001",
"0.71174693",
"0.7113862",
"0.7081324",
"0.7017677",
"0.7017677",
"0.7017677",
"0.69003886",
"0.679636",
"0.67469805",
"0.66896033",
"0.6640042",
"0.66054326",
"0.6576339",
"0.6576339",
"0.6576339",
"0.6549182",
"0.6549182",
"0.64778554... | 0.0 | -1 |
End offset of the segment | def end(self):
return self.end_ | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getEnd(self):\n return _libsbml.LineSegment_getEnd(self)",
"def end(self):\n return self.start + self.size",
"def endaddr(self):\n return self.startaddr + self.size",
"def _get_end(self):\n return self._end",
"def get_end(self):\n return self.__end",
"def getEnd(self) -> lo... | [
"0.73068535",
"0.72605735",
"0.72010446",
"0.699925",
"0.6922253",
"0.6915124",
"0.68964475",
"0.6843549",
"0.68276006",
"0.6826976",
"0.67586005",
"0.6580891",
"0.6480106",
"0.64694715",
"0.64635617",
"0.6447487",
"0.64299506",
"0.6396373",
"0.63472545",
"0.63421696",
"0.634... | 0.6141078 | 31 |
Name of the tag | def name(self):
return self.name_ | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tag(self) -> str:\n return self.name or ''",
"def get_tag_name(self):\n\n pass",
"def tag_name(self) -> str:\n return pulumi.get(self, \"tag_name\")",
"def get_name(self):\n return self.tagnode",
"def tag_name(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"ta... | [
"0.8629432",
"0.856235",
"0.84365237",
"0.80975956",
"0.8038163",
"0.7732518",
"0.764949",
"0.76234204",
"0.7597434",
"0.7510624",
"0.74376386",
"0.74048376",
"0.7393784",
"0.73702985",
"0.73563516",
"0.7353813",
"0.7353813",
"0.7353813",
"0.7353813",
"0.7344953",
"0.73428065... | 0.0 | -1 |
Value of the tag | def tag(self):
return self.tag_ | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tag_value(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"tag_value\")",
"def get(self):\n return self.tag.get()",
"def value(self):\n return self.raw.get_attribute(\"value\")",
"def value(self):\n return self.element.get_attribute('value')",
"def value(self):\... | [
"0.7868648",
"0.764538",
"0.76248944",
"0.7556161",
"0.7556161",
"0.7556161",
"0.747307",
"0.74238324",
"0.74004674",
"0.7335146",
"0.730605",
"0.7223917",
"0.72173995",
"0.7187691",
"0.71812",
"0.7105039",
"0.70779276",
"0.7067446",
"0.70370305",
"0.70255345",
"0.70255345",
... | 0.6916473 | 41 |
Computes the Jacobian of y wrt x assuming minibatchmode. | def _get_minibatch_jacobian(y, x, create_graph=False):
assert y.shape[0] == x.shape[0]
y = y.view(y.shape[0], -1)
# Compute Jacobian row by row.
jac = []
for j in range(y.shape[1]):
dy_j_dx = torch.autograd.grad(y[:, j], x, torch.ones_like(y[:, j]), retain_graph=True,
create_graph=True)[0].view(x.shape[0], -1)
jac.append(torch.unsqueeze(dy_j_dx, 1))
jac = torch.cat(jac, 1)
return jac | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_minibatch_jacobian(y, x):\n assert y.shape[0] == x.shape[0]\n y = y.view(y.shape[0], -1)\n\n # Compute Jacobian row by row.\n jac = []\n for j in range(y.shape[1]):\n dy_j_dx = torch.autograd.grad(y[:, j], x, torch.ones_like(y[:, j]), retain_graph=True,\n ... | [
"0.8049506",
"0.7586799",
"0.7340082",
"0.7092742",
"0.70245093",
"0.6984471",
"0.6948992",
"0.68618804",
"0.6859211",
"0.6838144",
"0.6793028",
"0.67266047",
"0.6696106",
"0.66701853",
"0.6601887",
"0.6596935",
"0.65616024",
"0.65616024",
"0.6518664",
"0.6505477",
"0.6503522... | 0.7515247 | 2 |
Return a Expression_obj whose name is gene_id | def __init__(self):
# self.organism = []
self.weighting_dict = defaultdict(list)
# self.codon_obj_dict = {}
self.codon_dict = {
'UUU':'F','UUC':'F',
'UUA':'L','UUG':'L','CUU':'L','CUC':'L','CUA':'L','CUG':'L',
'AUU':'I','AUC':'I','AUA':'I',
'AUG':'M',
'GUU':'V', 'GUC':'V','GUA':'V','GUG':'V',
'UCU':'S','UCC':'S','UCA':'S','UCG':'S',
'CCU':'P','CCC':'P','CCA':'P','CCG':'P',
'ACU':'T','ACC':'T','ACA':'T','ACG':'T',
'GCU':'A','GCC':'A','GCA':'A','GCG':'A',
'UAU':'Y','UAC':'Y',
'UAA':'X','UAG':'X',
'CAU':'H','CAC':'H',
'CAA':'Q','CAG':'Q',
'AAU':'N','AAC':'N',
'AAA':'K','AAG':'K',
'GAU':'D','GAC':'D',
'GAA':'E','GAG':'E',
'UGU':'C','UGC':'C',
'UGA':'X',
'UGG':'W',
'CGU':'R','CGC':'R','CGA':'R','CGG':'R',
'AGU':'S','AGC':'S',
'AGA':'R','AGG':'R',
'GGU':'G','GGC':'G', 'GGA':'G','GGG':'G'
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_gene(self, gene_id, source=\"eid\"):\n\n gene_id = str(gene_id)\n\n \n try:\n valid_gene = self.gene_cache[self.source_cache[source][gene_id]]\n return valid_gene\n except KeyError:\n pass\n \n valid_eid = None\n\n if source ... | [
"0.6313475",
"0.63014066",
"0.6045709",
"0.5961227",
"0.5909269",
"0.5827519",
"0.5769331",
"0.5765576",
"0.57507443",
"0.57040155",
"0.56940395",
"0.5685017",
"0.5614033",
"0.55961704",
"0.55855423",
"0.5572768",
"0.5556484",
"0.5548169",
"0.5545586",
"0.5535128",
"0.5527104... | 0.0 | -1 |
Constructs a Octave ResNet26 model. | def pre_act_oct_resnet26(pretrained=False, **kwargs):
model = PreActOctResNet(Bottleneck, [2, 2, 2, 2], **kwargs)
return model | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resnet10(shortcut_type, num_classes, in_channels):\n model = ResNet(BasicBlock, [1, 1, 1, 1], shortcut_type, num_classes, in_channels)\n return model",
"def resnet34(shortcut_type, num_classes, in_channels):\n model = ResNet(BasicBlock, [3, 4, 6, 3], shortcut_type, num_classes, in_channels)\n ret... | [
"0.65736985",
"0.6366523",
"0.6366468",
"0.6340577",
"0.6290355",
"0.62448686",
"0.6211965",
"0.62079406",
"0.6202202",
"0.61859906",
"0.617765",
"0.6167639",
"0.6150246",
"0.6131579",
"0.61293316",
"0.6126124",
"0.60872185",
"0.60808474",
"0.60243255",
"0.6022623",
"0.601866... | 0.64773536 | 1 |
Constructs a Octave ResNet50 model. | def pre_act_oct_resnet50(pretrained=False, **kwargs):
model = PreActOctResNet(Bottleneck, [3, 4, 6, 3], **kwargs)
return model | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resnet50(pretrained=False, **kwargs):\n model = ResNet(Bottleneck, [3, 4, 6, 3], **kwargs)\n if pretrained:\n model.load_state_dict(model_zoo.load_url(model_urls['resnet50']))\n fc = transfer_fc(model.fc)\n model.fc = fc\n return model",
"def ResNet50_model(input_shape, pooling):\n f... | [
"0.6788361",
"0.67803186",
"0.674441",
"0.6740062",
"0.6740062",
"0.6740062",
"0.6740062",
"0.67154825",
"0.67154825",
"0.6712815",
"0.6572177",
"0.6566482",
"0.6549519",
"0.6523207",
"0.64100075",
"0.6408448",
"0.6368369",
"0.6368369",
"0.6367889",
"0.63454634",
"0.6303097",... | 0.66204983 | 10 |
Constructs a Octave ResNet101 model. | def pre_act_oct_resnet101(pretrained=False, **kwargs):
model = PreActOctResNet(Bottleneck, [3, 4, 23, 3], **kwargs)
return model | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resnet101(pretrained=False, **kwargs):\n model = ResNet('resnet101', Bottleneck, [3, 4, 23, 3], **kwargs)\n if pretrained:\n model.load_state_dict(model_zoo.load_url(model_urls['resnet101']))\n return model",
"def resnet101(pretrained=False, **kwargs):\n model = ResNet(Bottleneck, [3, 4, 2... | [
"0.6975478",
"0.6963279",
"0.6944051",
"0.6944051",
"0.6944051",
"0.6944051",
"0.69128805",
"0.68887615",
"0.6869963",
"0.6868124",
"0.68124294",
"0.6709491",
"0.6664259",
"0.6648746",
"0.66283625",
"0.66283625",
"0.65992206",
"0.65794027",
"0.6534455",
"0.6504741",
"0.646747... | 0.6689366 | 12 |
Constructs a Octave ResNet152 model. | def pre_act_oct_resnet152(pretrained=False, **kwargs):
model = PreActOctResNet(Bottleneck, [3, 8, 36, 3], **kwargs)
return model | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_model(self):\r\n\r\n self.model = ResNet152V2(weights='imagenet')",
"def resnet152(pretrained=False, **kwargs):\n model = ResNet('resnet152', Bottleneck, [3, 8, 36, 3], **kwargs)\n if pretrained:\n model.load_state_dict(model_zoo.load_url(model_urls['resnet152']))\n return model"... | [
"0.71429336",
"0.71426964",
"0.70883363",
"0.7048324",
"0.70366234",
"0.70190185",
"0.6981999",
"0.6981999",
"0.6981999",
"0.6981999",
"0.6969816",
"0.6943194",
"0.6817958",
"0.67309207",
"0.6713831",
"0.6711944",
"0.6711944",
"0.6689598",
"0.6594432",
"0.65649575",
"0.624270... | 0.6930058 | 12 |
Constructs a Octave ResNet200 model. | def pre_act_oct_resnet200(pretrained=False, **kwargs):
model = PreActOctResNet(Bottleneck, [3, 24, 36, 3], **kwargs)
return model | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resnet10(**kwargs):\n model = ResNet(BasicBlock, [1, 1, 1, 1], **kwargs)\n return model",
"def resnet18(**kwargs):\n model = ResNet(BasicBlock, [2, 2, 2, 2], **kwargs)\n return model",
"def resnet200(**kwargs):\n model = ResNet(Bottleneck, [3, 24, 36, 3], **kwargs)\n return model",
"def... | [
"0.6754732",
"0.6618465",
"0.65908283",
"0.63108593",
"0.63079596",
"0.62873125",
"0.62037766",
"0.61919415",
"0.61760974",
"0.61187875",
"0.6101522",
"0.60922974",
"0.6071278",
"0.6071278",
"0.6071278",
"0.6071278",
"0.6071278",
"0.60647464",
"0.6059056",
"0.6056413",
"0.602... | 0.66531056 | 1 |
The standard size of a tile sprite in 2D screen space. | def tile_size_2d(self):
return 32.0, 32.0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cellsize_2d(self):\t\r\n return self.dx * self.dy",
"def pixelSize(self):\n br = self.sceneBoundingRect()\n if self.image is None:\n return 1,1\n return br.width()/self.width(), br.height()/self.height()",
"def get_pixel_size(self):\n p0 = core.PointF(0, 0)\n ... | [
"0.677379",
"0.6732188",
"0.6701107",
"0.6691744",
"0.6675488",
"0.66745335",
"0.666135",
"0.6641239",
"0.6588583",
"0.6561213",
"0.6488441",
"0.64793986",
"0.6465913",
"0.64484566",
"0.6422894",
"0.6421343",
"0.6418597",
"0.6404673",
"0.639991",
"0.6364815",
"0.63445616",
... | 0.79170084 | 0 |
Sets the cell at the given position to the tile given via the tile index. | def set_cell(self, x, y, tile_index):
data_index = x + y * self._size[0] # type: int
# self._data[data_index] = tile_index
#
# if self._sprites[data_index]:
# self._sprites[data_index].delete()
# self._sprites[data_index] = None
# Release resources
if self._tiles[data_index]:
self._tiles[data_index].delete()
self._tiles[data_index] = None
# Only create sprite when not zero
if tile_index:
tile_prototype = self._tile_set.get(tile_index, None) # type: Optional[Tile]
if not tile_prototype:
raise TileSetError("tile set does not contain tile for index %s" % tile_index)
tile_w, tile_h = self._tile_size_2d
i, j, _k = cart_to_iso(x, y, 0)
ax, ay = tile_prototype.anchor
tile_x, tile_y = i * tile_w - ax, j * tile_h - ay
tile = deepcopy(tile_prototype)
tile.sprite = pyglet.sprite.Sprite(tile.image, tile_x, tile_y)
tile.aabb3d.pos = float(x), float(y), 0.0
tile.aabb2d.pos = tile_x, tile_y
self._tiles[data_index] = tile
# self._sprites[data_index] = pyglet.sprite.Sprite(tile.image, tile_x, tile_y)
# Currently only supports a single level, so everything is on z-level 0
# self._aabb3d[data_index] = AABB3D(float(x), float(y), 0.0, tile.size[0], tile.size[1], tile.size[2])
# self._aabb2d[data_index] = AABB2D(tile_x, tile_y, tile_w, tile_h) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_tile(self, row, col, value):\r\n # replace with your code\r\n self._cells[row][col] = value",
"def set_tile(self, row, col, value):\n # replace with your code\n self._cells[row][col] = value",
"def set_tile(self, row, col, value):\n self._cells[row][col] = value",
"... | [
"0.79476476",
"0.793965",
"0.792472",
"0.7922317",
"0.7811975",
"0.77657914",
"0.77657914",
"0.77415025",
"0.77413976",
"0.77362347",
"0.77177304",
"0.7665559",
"0.76413506",
"0.76413506",
"0.7600459",
"0.7590378",
"0.7555909",
"0.7555414",
"0.7547121",
"0.74911577",
"0.73877... | 0.77405584 | 9 |
Adds an object, to be managed and drawn by the tile map. | def add_object(self, obj):
self._objects.append(obj) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addObject(self,object):\n object.screen = self.screen\n object.parent = self\n self.addList.append(object)",
"def add_object(self, obj):\n\t\tself.objects.append(obj)",
"def add(self, obj):\n if isinstance(obj, Drawable):\n self._drawables.add(... | [
"0.77441376",
"0.7656286",
"0.75963026",
"0.7574792",
"0.75481164",
"0.7518914",
"0.74521136",
"0.737135",
"0.7309146",
"0.7289169",
"0.71311355",
"0.70795727",
"0.69718575",
"0.6938054",
"0.68440473",
"0.68283266",
"0.681699",
"0.68109393",
"0.67909193",
"0.6732807",
"0.6706... | 0.7219038 | 10 |
Sorts the drawables in an order that they can be rendered using the painter's algorithm (back to front). | def sort(self, key_func):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw(self, **kwargs):\n for o in sorted(self._drawables, key=default_itemgetter(\"z\", default=0)):\n o.draw(**kwargs)",
"def start_sorting(self):\n if self.sorting:\n return None\n self.sorting = True\n\n passes = 0\n while self.sorting:\n ... | [
"0.6645382",
"0.6610428",
"0.6208446",
"0.6029311",
"0.60101074",
"0.60021496",
"0.59987986",
"0.5927565",
"0.5859521",
"0.58288765",
"0.5824865",
"0.5824865",
"0.58011025",
"0.57603604",
"0.57544345",
"0.5688162",
"0.5662971",
"0.5642846",
"0.5616782",
"0.55934376",
"0.55926... | 0.0 | -1 |
Save the response string. | def writeresponse(self, rspstr):
self.response += rspstr | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_response(self, res) -> None:\n file = open(\"response_{}.json\".format(self.num_res), \"w\")\n file.write(str(res))\n file.close()",
"def save_response(self, request, response):\n response_dict = self.process_response(request.path, response)\n try:\n self.se... | [
"0.7586363",
"0.7441666",
"0.67181605",
"0.6693726",
"0.66190016",
"0.6497438",
"0.64742",
"0.6389973",
"0.6360549",
"0.62210476",
"0.6212932",
"0.6212932",
"0.6147369",
"0.6139059",
"0.6138615",
"0.6062147",
"0.60561544",
"0.6024466",
"0.602372",
"0.59702677",
"0.5941074",
... | 0.6328722 | 9 |
Using the Command_Handler from command module to handle command. | def usingHandler(self, cmd):
self.command_handler.handle_command(cmd)
while msg_queue.empty() is False:
self.writeresponse(msg_queue.get()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _command(self, *cmd, handler=None):",
"def _command(self, handlers, args, msg):\n com, arg = self._command_split(args)\n if com in handlers.subcommands:\n msg.inc_handlers()\n self._command(handlers.subcommands[com], arg, msg)\n for handler in handlers.handlers:\n ... | [
"0.8338623",
"0.75426656",
"0.7504038",
"0.7325603",
"0.7277105",
"0.726302",
"0.71191317",
"0.7092065",
"0.70484436",
"0.6998338",
"0.6996647",
"0.6957424",
"0.6936447",
"0.6885723",
"0.683087",
"0.6806178",
"0.676416",
"0.6748807",
"0.6729248",
"0.6727872",
"0.67130303",
... | 0.77345246 | 1 |
Attach ipmiconsole to target instance specified by its name | def start(instance="default"):
# initialize logging
global logger_ic
logger_ic = infrasim_log.get_logger(LoggerType.ipmi_console.value, instance)
common.init_logger(instance)
# initialize environment
env.local_env.quit_flag = False
common.init_env(instance)
pid_file = "{}/{}/.ipmi_console.pid".format(config.infrasim_home, instance)
daemon.daemonize(pid_file)
with open(pid_file, "r") as fp:
logger_ic.info("ipmi-console of {} start with pid {}".
format(instance, fp.read().strip()))
# parse the sdrs and build all sensors
sdr.parse_sdrs()
# running thread for each threshold based sensor
_start_monitor(instance)
_spawn_sensor_thread()
_start_console(instance) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def launch_new_instance():\n import IPython\n\n IPython.Shell.start().mainloop()",
"def attach(self):\r\n sshpass = \"sshpass -p \\\"akanksha1\\\"\"\r\n remote_Station = \"root@192.168.54.24\"\r\n base = \"ssh -t \" + options[\"username\"] + \"@\" + options[\"server\"]\r\n\r\n s... | [
"0.555184",
"0.53565377",
"0.5350084",
"0.52938074",
"0.527807",
"0.51141536",
"0.503388",
"0.5028491",
"0.5026515",
"0.50112593",
"0.50111884",
"0.49634692",
"0.49329525",
"0.4874104",
"0.48671383",
"0.4858034",
"0.48359525",
"0.48175284",
"0.48108807",
"0.47951758",
"0.4767... | 0.5010261 | 11 |
Target method used by monitor thread, which polls vbmc status every 3s. If vbmc stops, ipmiconsole will stop. | def monitor(instance="default"):
global logger_ic
while True:
try:
with open("{}/{}/.{}-bmc.pid".format(
config.infrasim_home, instance, instance), "r") as f:
pid = f.readline().strip()
if not os.path.exists("/proc/{}".format(pid)):
logger_ic.warning("Node {} vBMC {} is not running, "
"ipmi-console is ready to quit".
format(instance, pid))
break
time.sleep(3)
except IOError:
logger_ic.warning("Node {} workspace is possibly destroyed, "
"ipmi-console is ready to quit".format(instance))
break
stop(instance) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def monitor(self, rms):\n pass",
"def monitor(self):\n while not self.terminated:\n try:\n if (time.time() - self.updated_time) < 5:\n messages = self.messages.copy()\n # procs = np.min([ len(messages), 9 ]) + 1\n ... | [
"0.6409184",
"0.627425",
"0.62064976",
"0.61520576",
"0.61488384",
"0.608878",
"0.6028219",
"0.60113215",
"0.58789355",
"0.586533",
"0.5813013",
"0.5793242",
"0.57749766",
"0.5774655",
"0.5764802",
"0.57504106",
"0.57363623",
"0.5703783",
"0.57020646",
"0.56902844",
"0.568184... | 0.65879107 | 0 |
Create a monitor thread to watch vbmc status. | def _start_monitor(instance="default"):
global logger_ic
logger_ic = infrasim_log.get_logger(LoggerType.ipmi_console.value, instance)
logger_ic.info("ipmi-console monitor thread starts to run.")
monitor_thread = threading.Thread(target=monitor, args=(instance,))
monitor_thread.setDaemon(True)
monitor_thread.start() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _StartStatusUpdateThread(self):\n self._status_update_active = True\n self._status_update_thread = threading.Thread(\n name='Status update', target=self._StatusUpdateThreadMain)\n self._status_update_thread.start()",
"def run(self):\n self.monitor.start()",
"def run():\n logger.ve... | [
"0.63383204",
"0.6285425",
"0.6240025",
"0.5985517",
"0.59852713",
"0.59686154",
"0.5919293",
"0.59185845",
"0.5913581",
"0.5894443",
"0.58611625",
"0.58052415",
"0.579297",
"0.5792904",
"0.5758416",
"0.5757731",
"0.57059795",
"0.57036275",
"0.5703507",
"0.56903523",
"0.56861... | 0.62090486 | 3 |
Stop ipmiconsole of target instance specified by its name | def stop(instance="default"):
global logger_ic
logger_ic = infrasim_log.get_logger(LoggerType.ipmi_console.value, instance)
try:
file_ipmi_console_pid = "{}/{}/.ipmi_console.pid".\
format(config.infrasim_home, instance)
with open(file_ipmi_console_pid, "r") as f:
pid = f.readline().strip()
os.kill(int(pid), signal.SIGTERM)
logger_ic.info("SIGTERM is sent to pid: {}".format(pid))
os.remove(file_ipmi_console_pid)
except IOError:
# When pid file is missing, by e.g., node destroy,
# find process id by instance name
if instance == "default":
process_name = "ipmi-console start$"
else:
process_name = "ipmi-console start {}".format(instance)
ps_cmd = r"ps ax | grep '{}' | grep Sl | awk '{{print $1}}' | head -n1".format(process_name)
logger_ic.warning("Fail to find ipmi console pid file, check by:")
logger_ic.warning("> {}".format(ps_cmd))
_, pid = run_command(cmd=ps_cmd)
logger_ic.warning("ipmi console pid got: {}".format(pid))
if not pid:
logger_ic.warning("ipmi console for instance {} is not running".format(instance))
return
os.kill(int(pid), signal.SIGTERM)
logger_ic.info("SIGTERM is sent to pid: {}".format(pid))
except Exception:
logger_ic.warning(traceback.format_exc())
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stop(self):\n self.scion_sh('stop')",
"def processStop(name):\n imrclient.update_server_info()\n imrclient.process_stop(name)",
"def stop_notebook_instance(NotebookInstanceName=None):\n pass",
"def stop(self):\n if self.debug:\n print(\"%s stop\" % self.name)\n s... | [
"0.69108975",
"0.6825068",
"0.6671944",
"0.6663248",
"0.66268575",
"0.65905327",
"0.65741503",
"0.6553872",
"0.6435648",
"0.6377335",
"0.6354143",
"0.63085943",
"0.6253596",
"0.6247487",
"0.62375504",
"0.62224996",
"0.62192184",
"0.61786765",
"0.6176067",
"0.6176067",
"0.6176... | 0.6886424 | 1 |
Return an upload ID. | def startupload(request):
if "parent" in request.POST:
parent = models.Character.objects.get(pk=request.POST["parent"])
else:
parent = None
c = models.Character(parent=parent)
c.save()
d = json.loads(request.POST['data'])
for k, v in d["texts"].items():
set_text(c, k, v)
for k, v in d["sounds"].items():
set_sound(c, k, v)
return JsonResponse({"id": c.pk}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initiate_multipart_upload(self):\n request = self.s3.create_request(\"OBJECT_POST\", uri = self.uri, headers = self.headers_baseline, extra = \"?uploads\")\n response = self.s3.send_request(request)\n data = response[\"data\"]\n self.upload_id = getTextFromXml(data, \"UploadId\")\n ... | [
"0.6757901",
"0.67014873",
"0.6528737",
"0.6503102",
"0.644656",
"0.6368345",
"0.6355548",
"0.62546957",
"0.6124786",
"0.6089393",
"0.6034663",
"0.6034663",
"0.5999296",
"0.5985921",
"0.59466124",
"0.59466124",
"0.5939695",
"0.5939695",
"0.5924135",
"0.5912577",
"0.5890405",
... | 0.0 | -1 |
Creates a handle to the Ceph Cluster. | def connect(ceph_config_file, timeout = CEPH_TIMEOUT):
handle = rados.Rados(conffile = ceph_config_file)
LOGGER.info("librados version: " + str(handle.version()))
LOGGER.info("Attempting to connect to: " +
str(handle.conf_get('mon initial members')))
handle.connect() #timeout shoudl be specified
LOGGER.info("Cluster ID" + handle.get_fsid())
return handle | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_ceph_info(handle, ceph_config, timeout):\n cluster = dict()\n\n cluster['status'] = ceph_mon_command(handle,\n 'status', timeout)\n cluster['version'] = shell_command('ceph -v') + b'\\n'\n\n # ceph versions command was introduced in mimic\n version = c... | [
"0.6605776",
"0.6418442",
"0.6327758",
"0.61983645",
"0.61876357",
"0.61836255",
"0.6062055",
"0.6059325",
"0.60109323",
"0.5957398",
"0.5952814",
"0.58882135",
"0.58059293",
"0.57884413",
"0.5772146",
"0.5749063",
"0.57396287",
"0.5687946",
"0.5676263",
"0.56761366",
"0.5651... | 0.6422216 | 1 |
execute a shell command in the cluster | def shell_command(command, shell=True):
p = subprocess.Popen(command, stdout=subprocess.PIPE, shell=shell)
result = p.communicate()[0]
if result == "command not known":
LOGGER.info("command not known " + err)
return result.strip() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def execute(cmd) :\n return os.system( cmd )",
"def do_shell(self, command):\n os.system(command)",
"def raw_cluster_cmd(self, *args, **kwargs):\n proc = self.controller.run(args=[os.path.join(BIN_PREFIX, \"ceph\")] + \\\n list(args), **kwargs)\n r... | [
"0.682894",
"0.6679226",
"0.6656794",
"0.66437536",
"0.6632637",
"0.6577042",
"0.65581995",
"0.65328985",
"0.65173554",
"0.65003866",
"0.64953446",
"0.6490907",
"0.64615303",
"0.64323294",
"0.6411985",
"0.63707674",
"0.6368736",
"0.63686305",
"0.6345518",
"0.631454",
"0.63143... | 0.0 | -1 |
Gather overall cluster information | def get_ceph_info(handle, ceph_config, timeout):
cluster = dict()
cluster['status'] = ceph_mon_command(handle,
'status', timeout)
cluster['version'] = shell_command('ceph -v') + b'\n'
# ceph versions command was introduced in mimic
version = cluster['version']
version = str(version.decode('utf-8')).split(' ')[2].split(".")[0]
if int(version) >= 13:
cluster['versions'] = shell_command('ceph versions') + b'\n'
fsid = handle.get_fsid() + '\n'
cluster['fsid'] = str.encode(fsid)
with open(ceph_config, 'r') as f:
ceph_conf = f.read()
cephconf = str(ceph_conf)
cluster['ceph_conf'] = str.encode(cephconf)
return cluster | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_cluster_info(self) -> Dict[str, Any]:\n pass",
"def collect_cluster_info(output_dir, k8s_cli):\n collect_helper(output_dir, cmd=\"{} cluster-info\".format(k8s_cli),\n file_name=\"cluster_info\", resource_name=\"cluster-info\")",
"def show_overview(self) -> None:\n pri... | [
"0.7719436",
"0.74022055",
"0.73409766",
"0.7059982",
"0.6924038",
"0.6866448",
"0.67935354",
"0.67794836",
"0.6743119",
"0.6643425",
"0.66368085",
"0.6614722",
"0.6586277",
"0.6576589",
"0.6573444",
"0.6546255",
"0.65434664",
"0.651949",
"0.6503765",
"0.64962125",
"0.6486102... | 0.0 | -1 |
Gather cluster health information | def get_health_info(handle, timeout):
health = dict()
health['stat'] = ceph_mon_command(handle, 'health' , timeout)
# TODO command not known with ceph_mon_command
#health['detail'] = ceph_mon_command(handle, 'health detail', timeout)
health['detail'] = shell_command('ceph health detail') + b'\n'
health['df'] = ceph_mon_command(handle, 'df' , timeout)
health['report'] = ceph_mon_command(handle, 'report' , timeout)
return health | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cluster_health(self, host):\n\n h = self.call_to_cluster(host, '/_cluster/health')\n\n data = {\n 'number_of_nodes': h['number_of_nodes'],\n 'unassigned_shards': h['unassigned_shards'],\n 'timed_out': h['timed_out'],\n 'active_primary_shards': h['active... | [
"0.8006035",
"0.7863848",
"0.71975887",
"0.700192",
"0.6814766",
"0.6722469",
"0.6707405",
"0.66621304",
"0.665207",
"0.65768224",
"0.65568644",
"0.6537222",
"0.6509707",
"0.6436703",
"0.6426991",
"0.64085305",
"0.6380572",
"0.6379265",
"0.63764757",
"0.63066256",
"0.62769216... | 0.68823427 | 4 |
Gather ceph monitor information | def get_monitor_info(handle, timeout):
mon_info = dict()
mon_info['stat'] = ceph_mon_command(handle, 'mon stat' , timeout)
mon_info['dump'] = ceph_mon_command(handle, 'mon dump' , timeout)
mon_info['map'] = ceph_mon_command(handle, 'mon getmap' , timeout)
mon_info['metadata'] = ceph_mon_command(handle, 'mon metadata', timeout)
return mon_info | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def get_monitor_data(self):\n json = await self._api_call(\"app/monitors/%s/overview\" % self.sense_monitor_id)\n if \"monitor_overview\" in json and \"monitor\" in json[\"monitor_overview\"]:\n self._monitor = json[\"monitor_overview\"][\"monitor\"]\n return self._monitor",
... | [
"0.66455966",
"0.6420232",
"0.64127403",
"0.6299886",
"0.6260533",
"0.6227388",
"0.6212769",
"0.6193962",
"0.6172191",
"0.6142712",
"0.60478276",
"0.6043625",
"0.60359365",
"0.5971578",
"0.5969627",
"0.5957598",
"0.5948469",
"0.5928224",
"0.5919851",
"0.5902216",
"0.58823013"... | 0.7485646 | 0 |
GAther ceph device information | def get_device_info(handle, timeout):
device_info = dict()
device_info['ls'] = ceph_mon_command(handle, 'device ls', timeout)
return device_info | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def device_info(self) -> Dict[str, Any]:\n via_device = 'meter_adapter'\n if self.toon.gas.is_smart:\n via_device = 'electricity'\n\n return {\n 'name': 'Gas Meter',\n 'identifiers': {\n (DOMAIN, self.toon.agreement.id, 'gas'),\n },\n ... | [
"0.6951333",
"0.6848414",
"0.6711916",
"0.6700383",
"0.667151",
"0.66525185",
"0.6542051",
"0.6531767",
"0.6522371",
"0.6514975",
"0.64998937",
"0.64957225",
"0.6470811",
"0.6451061",
"0.6438751",
"0.6416084",
"0.64145595",
"0.6406177",
"0.63985395",
"0.63964",
"0.63928473",
... | 0.6898668 | 1 |
Gather ceph manager information | def get_manager_info(handle, timeout):
mgr_info = dict()
mgr_info['ls-modules'] = ceph_mon_command(handle, 'mgr module ls', timeout)
mgr_info['dump'] = ceph_mon_command(handle, 'mgr dump' , timeout)
mgr_info['metadata'] = ceph_mon_command(handle, 'mgr metadata' , timeout)
return mgr_info | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def manager_info(self, manager):\n _, body = self.request('/v1.1/managers/active/%s' % manager, 'GET')\n return body",
"def get_ceph_info(handle, ceph_config, timeout):\n cluster = dict()\n\n cluster['status'] = ceph_mon_command(handle,\n 'status', time... | [
"0.65334594",
"0.6489982",
"0.6204253",
"0.60092634",
"0.6008082",
"0.5893398",
"0.5754568",
"0.5699375",
"0.56716347",
"0.5611492",
"0.5582611",
"0.5579014",
"0.5577621",
"0.5576179",
"0.55696046",
"0.5542833",
"0.55382943",
"0.55256027",
"0.5521256",
"0.55209965",
"0.551072... | 0.7890347 | 0 |
Writes the diagnostics to specific files and creates a tarball for the same | def dict_to_files(result_dict, dest_dir):
tempdir = tempfile.mkdtemp()
# timestamp every generated dignostic file
timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%I%S")
tarball = '{0}/ceph-collect_{1}.tar.gz'.format(dest_dir, timestamp)
with tarfile.open(tarball, 'w:gz') as tar:
for filename, content in result_dict.items():
for contentname, contentdata in content.items():
tmpfile = '{0}/{1}'.format(tempdir, filename +
"-" + contentname)
LOGGER.debug('Writing file %s', tmpfile)
print('Writing file %s', tmpfile)
with open(tmpfile, 'wb') as f:
f.write(contentdata)
f.close()
tar.add(name=tmpfile,
arcname='ceph-collect_{0}/{1}'.format(timestamp,
filename + "-" +
contentname))
tar.close()
LOGGER.info("Diagnostics are written to : "+ tarball)
LOGGER.info("Cleaning up temporary directory")
shutil.rmtree(tempdir) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_tarball(args, tarfilename, archivefiles=[]):\n if not archivefiles:\n return None\n \n manifest_filename, manifest_uuid = render_manifest(args, archivefiles)\n try:\n with tarfile.open(tarfilename, f\"{FILE_FLAG}:gz\") as tarball:\n file_count = 0\n for fna... | [
"0.6348986",
"0.62728393",
"0.6065827",
"0.6017353",
"0.6005254",
"0.6003141",
"0.5832814",
"0.57835436",
"0.5780004",
"0.57281613",
"0.57143897",
"0.57073367",
"0.5691607",
"0.566522",
"0.55969507",
"0.55673474",
"0.5560966",
"0.55485785",
"0.5524467",
"0.5479293",
"0.546824... | 0.53366596 | 38 |
Ensure this function returns the correct number of entities with the specified tag. | def test_get_sets_by_category():
group_categories = get_sets_by_category(mb, "Group")
assert len(group_categories) == 5 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_count(self, tag: Text) -> int:\r\n sub_tags = tag.split(\"+\")\r\n return len([e for e in self.elements if all(t in e.tags for t in sub_tags)])",
"def getTagsNum(self):\r\n self.gettags()",
"def count_tags():\r\n trans = transaction.begin()\r\n StatBookmarkMgr.count_total_tag... | [
"0.70608175",
"0.678857",
"0.6734028",
"0.65930325",
"0.64529455",
"0.62508005",
"0.6231032",
"0.62118965",
"0.61979675",
"0.6197728",
"0.6096715",
"0.6096469",
"0.6078573",
"0.59946",
"0.59408474",
"0.5923345",
"0.59161204",
"0.590068",
"0.5879492",
"0.5843947",
"0.58285606"... | 0.0 | -1 |
Ensure this function returns the correct list of entity sets without the graveyard volume. | def test_locate_graveyard():
groups_to_write, graveyard_sets = locate_graveyard(mb)
assert groups_to_write == [12682136550675318125, 12682136550675318126,
12682136550675318128, 12682136550675318129] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def available_sets(session, player):\n excluded_sets = set(session.taken.keys())\n for grouping in session.exclusives:\n if player.sets.intersection(grouping):\n excluded_sets.update(grouping)\n return [s for s in session.sets if s not in excluded_sets]",
"def gather_entities(self):\n ... | [
"0.6598351",
"0.6436746",
"0.6417409",
"0.6331896",
"0.6149638",
"0.604962",
"0.5946124",
"0.58908427",
"0.5782512",
"0.57297885",
"0.571627",
"0.55856144",
"0.55809915",
"0.5561783",
"0.5537913",
"0.5536738",
"0.5535733",
"0.54536754",
"0.5453462",
"0.5442003",
"0.53676707",... | 0.0 | -1 |
Ensure this function returns the correct default output file name. | def test_default_format_file_name():
output_name = format_file_name(test_file)
assert (output_name == test_file[:-4] + "_no_grave.h5m") == True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def output_file_name(self) -> typing.Optional[str]:\n return self._values.get(\"output_file_name\")",
"def output_file_name(self) -> typing.Optional[str]:\n return self._values.get(\"output_file_name\")",
"def output_file_name(self) -> typing.Optional[str]:\n return self._values.get(\"outp... | [
"0.7893717",
"0.7893717",
"0.7893717",
"0.7893717",
"0.7785941",
"0.77704704",
"0.7656715",
"0.7550296",
"0.7494922",
"0.7245793",
"0.71426344",
"0.7105859",
"0.707106",
"0.70194244",
"0.7014153",
"0.6989266",
"0.69176805",
"0.69050795",
"0.6865408",
"0.68430066",
"0.6822271"... | 0.69034684 | 18 |
Ensure this function returns the correct user input file name. | def test_option_format_file_name():
output_name = format_file_name(test_file, 'test_output.h5m')
assert (output_name == 'test_output.h5m') == True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def file_path():\n file_name = input(\"Enter the file name:\")\n return file_name",
"def obtain_filename():\n file_wanted = input(\"Filename? \")\n return file_wanted",
"def file_name_request(self):\n self.file_name = input(\"What is the name of the input file?\\n>>>\")",
"def get_filename... | [
"0.8286607",
"0.8252012",
"0.80501723",
"0.76167345",
"0.7578909",
"0.74168056",
"0.73490226",
"0.7260431",
"0.72341657",
"0.723208",
"0.7181744",
"0.71346575",
"0.70963013",
"0.7040597",
"0.70244354",
"0.7022156",
"0.6870741",
"0.68621856",
"0.68099684",
"0.6801889",
"0.6728... | 0.0 | -1 |
Ensure that graveyard_removal.py correctly removes the graveyard from an h5m file. | def test_default_graveyard_removal():
os.system("python svalinn_tools/graveyard_removal.py " + test_file_path + test_file)
size = os.path.getsize(test_file[:-4] + "_no_grave.h5m")
assert size == 5748780 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_cleanup():\n os.remove(test_file[:-4] + \"_no_grave.h5m\")",
"def remove_group(self):\n try:\n with open_hdf5(self.file_name, mode=\"a\") as hdf_file:\n del hdf_file[self.h5_path]\n except KeyError:\n pass",
"def cleanup_file(name: str):\n if os... | [
"0.64098233",
"0.6114747",
"0.58413917",
"0.582247",
"0.57496554",
"0.56727177",
"0.5573327",
"0.5490028",
"0.54383737",
"0.53650856",
"0.53048605",
"0.5302251",
"0.5285933",
"0.5256595",
"0.52538306",
"0.5244757",
"0.5230618",
"0.5228572",
"0.5218584",
"0.5204441",
"0.516990... | 0.7458633 | 0 |
Ensure that graveyard_removal.py prints the correct entity handle for the graveyard volume. | def test_print_graveyard_removal(capfd):
os.system("python svalinn_tools/graveyard_removal.py " + test_file_path + test_file + " -p")
out, err = capfd.readouterr()
assert ("12682136550675318127" in out) == True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_volume(self):\n ctxt = context.get_admin_context()\n extra_specs = {}\n type_ref = volume_types.create(ctxt, 'hgst-1', extra_specs)\n volume = {'id': '1', 'name': 'volume1',\n 'display_name': '',\n 'volume_type_id': type_ref['id'],\n ... | [
"0.5670078",
"0.5624108",
"0.554459",
"0.5481827",
"0.5419034",
"0.53412575",
"0.5311965",
"0.52677137",
"0.518722",
"0.51854277",
"0.5156141",
"0.5146773",
"0.5126611",
"0.5102824",
"0.50757784",
"0.5075659",
"0.5067923",
"0.50451326",
"0.49824572",
"0.49812868",
"0.4970936"... | 0.6111419 | 0 |
Remove the files written to disk by this class of tests. | def test_cleanup():
os.remove(test_file[:-4] + "_no_grave.h5m") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tearDown(self):\n for f in os.listdir('/tmp'):\n if not f.startswith(self.FILE_PREFIX):\n continue\n\n os.remove(os.path.join('/tmp', f))",
"def tearDown(self) -> None:\n filtered = [f for f in glob.glob('steps/tests/test_output/*') if not re.match(r'\\.keep... | [
"0.8038646",
"0.80053955",
"0.79976135",
"0.7974729",
"0.7966363",
"0.78566366",
"0.7773938",
"0.7761133",
"0.77407455",
"0.7704826",
"0.76752174",
"0.76329154",
"0.76329154",
"0.76329154",
"0.7632071",
"0.7624899",
"0.761122",
"0.76048136",
"0.7599777",
"0.7578465",
"0.75228... | 0.0 | -1 |
Validate the regex patterns, but only partially while the user is still typing. Because the 'from' pattern will be where the user specifies captures, changing it also requires revalidating the substitution pattern. However if the user is still typing (as opposed to hitting enter to complete the input) we do the minimal amount of work necessary, i.e we just set the colors back to neutral and disable the Apply button. | def validateRegexFields(self, complete=False):
# Assume the patterns aren't valid.
self.m_validFromRe = False
self.m_validPatterns = False
### Validate the 'from' pattern
#
regexCtl = self.m_reFromCtl
subsCtl = self.m_reToCtl
regex, subs = regexCtl.Value, subsCtl.Value
regColor, subColor = wx.NullColour, wx.NullColour
if complete and regex:
regColor = subColor = wx.BLUE
try:
re.sub(regex, subs, '')
except re.error as e:
subColor = wx.RED
try:
re.compile(regex)
except re.error as e:
regColor = wx.RED
else:
self.m_validFromRe = True
else:
self.m_validFromRe = True
self.m_validPatterns = bool(subs)
self.setTextColor(regexCtl, regColor)
self.setTextColor(subsCtl, subColor)
if complete:
self.populateFileList()
else:
self.m_applyBtn.Enabled = False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def onTextChange(self, event):\n\n self.validateRegexFields(complete=False)\n event.Skip()",
"def onHitEnterInFrom(self, event):\n\n self.validateRegexFields(complete=True)\n if self.m_validFromRe:\n self.m_reToCtl.SetFocus()",
"def __checkForPattern(self):\n if se... | [
"0.6140925",
"0.6094179",
"0.60423654",
"0.56661874",
"0.5438786",
"0.53020585",
"0.5268809",
"0.51951706",
"0.5172561",
"0.50293213",
"0.501354",
"0.49975908",
"0.49453467",
"0.49100548",
"0.49090192",
"0.48892468",
"0.48374686",
"0.48184943",
"0.47469115",
"0.46745083",
"0.... | 0.7344064 | 0 |
Refresh our list of what's on disk. | def updateDiskFileList(self):
if self.m_curPath:
# Get me just the files please.
for _, _, files in os.walk(self.m_curPath):
break
else:
files = []
files.sort()
if files != self.m_diskNames:
self.m_diskNames[:] = files
self.m_newNames[:] = []
self.populateFileList() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def refresh(self):\n self.config.read(self.filename)\n self.loadRecentFiles()",
"def update(self):\n if os.path.isdir(self.full_path):\n self.file_list = os.listdir(self.full_path)\n else:\n self.file_list = []",
"def refresh(self, list_of_tables):\n sel... | [
"0.71091926",
"0.7044655",
"0.700236",
"0.68334323",
"0.68334323",
"0.6765857",
"0.66914636",
"0.66914636",
"0.66914636",
"0.65789855",
"0.65704066",
"0.65704066",
"0.6506549",
"0.6506549",
"0.6505286",
"0.6480908",
"0.6439831",
"0.6422957",
"0.64214545",
"0.64141774",
"0.632... | 0.70745224 | 1 |
Uses the list of filesondisk and the regex patterns to build a list of what the directory will look like if we renamed the files. Because we're justusing a simple text list, we use symbols to show the user which filenames would change and whether they would produce any duplicates, substituting "." with "\1.txt". | def populateFileList(self):
self.m_fileList.SetForegroundColour(wx.NullColour)
# We'll need to track which file names are modified and which
# file names duped.
applicable, dupes = set(), set()
if not self.m_validPatterns:
# Regex's don't compile yet, just use the raw filename list.
newNames = self.m_diskNames
else:
# Apply the substitution to the filename list to produce a
# destination-name list, and identify whether the patterns
# actually affect anything.
#
newNames, modifiedIndexes = [], []
matcher = re.compile(self.m_reFromCtl.Value).subn
subs = self.m_reToCtl.Value
for filename in self.m_diskNames:
# Perform the sub
(filename, numChanges) = matcher(subs, filename)
# Was there a modification?
if numChanges:
# Record the affected name.
applicable.add(filename)
if filename in newNames:
dupes.add(filename)
# Add to the primary list
newNames.append(filename)
# Does this produce a different list than we already had? If so,
# clear the file list and replace it with the new one.
#
if newNames != self.m_newNames:
self.m_fileList.Clear()
# Figure out the longest name so we can create a cleanly-formatted
# set of prefix/suffix characters for the modified/duped annotation.
#
maxLen = max(map(len, newNames))
decorate = '{m} {fn:<{ml}} {m}'.format
# Now build a list of display elements.
for filename in newNames:
mark = ' ' if filename not in applicable else '|'
if filename in dupes:
mark = '*'
self.m_fileList.Append(decorate(m=mark, fn=filename, ml=maxLen))
# Keep the list.
self.m_newNames[:] = newNames
# Update the apply button, we only want it enabled when the user
# has a valid set of patterns that affect any files and have no
# dupes produced as a result.
#
self.m_applyBtn.Enabled = bool(applicable) and not dupes
if dupes:
# Emphasize the presence of dupes.
self.m_fileList.SetForegroundColour(wx.RED)
# Draw the list.
self.m_fileList.Refresh() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rename_files(file_list, src_dir, pattern, rename=False):\n i = 0\n renamed = regex_group_split(file_list, pattern, False)\n renamed_w_path = [src_dir + fn for fn in renamed]\n orig_fp_list = orig_filepath_list(file_list, src_dir)\n\n for filename in file_list:\n if not (orig_fp_list[i] ==... | [
"0.62912023",
"0.6283787",
"0.61243826",
"0.61238414",
"0.6057",
"0.6056427",
"0.60261464",
"0.6002019",
"0.58697075",
"0.58516043",
"0.58399916",
"0.5831643",
"0.5815127",
"0.5750396",
"0.57445604",
"0.57320064",
"0.5677666",
"0.56666535",
"0.56408477",
"0.5636326",
"0.56356... | 0.6573242 | 0 |
Handle the user changing directory. | def onDirectorySelectionChanged(self, event):
newPath = self.m_directoryCtl.Path
if self.m_curPath == newPath:
return
self.m_applyBtn.Disable()
self.m_directoryCtl.ExpandPath(newPath)
# Clear the directory list.
self.m_fileList.Clear()
self.m_curPath = newPath
self.updateDiskFileList() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ChangeDir(self, path: str) -> None:\n ...",
"def change_base_dir():\n global base_dir\n while True:\n new_base = raw_input(\"New user directory? \")\n new_base = os.path.abspath(new_base)\n if os.path.exists(new_base):\n if os.path.isfile(new_base):\n ... | [
"0.71233064",
"0.688778",
"0.67881495",
"0.6747246",
"0.6743474",
"0.6619424",
"0.6606413",
"0.6544958",
"0.6513183",
"0.6458206",
"0.64284754",
"0.6231321",
"0.62166995",
"0.6192592",
"0.6178349",
"0.6172817",
"0.6166601",
"0.6157614",
"0.6141804",
"0.6134251",
"0.6129112",
... | 0.57040215 | 45 |
User has clicked the Apply button. | def onApply(self, event):
# Rename all of the files based on the substitution.
for (old, new) in zip(self.m_diskNames, self.m_newNames):
if old != new:
old = os.path.join(self.m_curPath, old)
new = os.path.join(self.m_curPath, new)
try:
os.rename(old, new)
except OSError:
pass
# Now we out the lists so that what the user sees after this
# reflects what's on disk.
self.m_diskNames[:] = []
self.m_newNames[:] = []
# Update.
self.updateDiskFileList() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dlg_apply(self):\n pass # override",
"def on_okButton_clicked(self):\n self.accept=True",
"def apply(event: EventType, widget: WidgetType) -> bool:\n return event.key == KEY_APPLY",
"def on_apply_clicked(self,button):\n\t\tdialog = ConfirmPerformActions()\n\t\t\n\t\tresponse = dialog... | [
"0.6905215",
"0.68310213",
"0.66178197",
"0.64573747",
"0.6415029",
"0.63940597",
"0.63610774",
"0.62184435",
"0.61905",
"0.6176993",
"0.6145998",
"0.61428314",
"0.60933006",
"0.6080761",
"0.6052281",
"0.59710234",
"0.59425336",
"0.5938652",
"0.5905501",
"0.5880406",
"0.58425... | 0.0 | -1 |
When the user hits 'enter' in the 'from' field. | def onHitEnterInFrom(self, event):
self.validateRegexFields(complete=True)
if self.m_validFromRe:
self.m_reToCtl.SetFocus() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handle_enter():\n enter_event = QtGui.QKeyEvent(\n QEvent.KeyPress, Qt.Key_Enter, Qt.KeyboardModifiers())\n QtGui.QApplication.sendEvent(self, enter_event)",
"def hit_enter():\n keyboard.press_and_release('Enter')",
"def enter(self):\n\t\tself.actionObject().key_... | [
"0.6778405",
"0.6758216",
"0.67262506",
"0.6404956",
"0.6386746",
"0.63825494",
"0.63070136",
"0.62395203",
"0.6209298",
"0.62009835",
"0.61862344",
"0.61658704",
"0.616317",
"0.6027476",
"0.6005713",
"0.5913",
"0.5905714",
"0.58879393",
"0.58879393",
"0.58485764",
"0.5829572... | 0.7331321 | 0 |
When the user hits 'enter' in the substitution field. | def onHitEnterInTo(self, event):
self.validateRegexFields(complete=True)
if self.m_validPatterns:
self.m_fileList.SetFocus() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hit_enter():\n keyboard.press_and_release('Enter')",
"def enter(self):\n\t\tself.actionObject().key_down(Keys.ENTER).key_up(Keys.ENTER).perform()",
"def press_enter():\n raw_input(\"\\n\\nPress Enter\")",
"def handle_enter():\n enter_event = QtGui.QKeyEvent(\n QEvent.K... | [
"0.7329176",
"0.6851118",
"0.683353",
"0.6715554",
"0.66356564",
"0.6603124",
"0.6601415",
"0.6570257",
"0.6491624",
"0.6442124",
"0.638937",
"0.62842214",
"0.62780654",
"0.6265659",
"0.6146514",
"0.6146514",
"0.61026675",
"0.60870814",
"0.60781586",
"0.6066289",
"0.6063572",... | 0.5933596 | 26 |
When the user modifies the content of either regex field. | def onTextChange(self, event):
self.validateRegexFields(complete=False)
event.Skip() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_field(self, **kwargs):\n if self.regex:\n if not 'regex' in self.field_args:\n self.field_args = self.field_args + ('regex', )\n self.field_klass = forms.RegexField\n return super(StringSetting, self).to_field(**kwargs)",
"def get_regex_mismatch_error_tex... | [
"0.59722745",
"0.58232623",
"0.5730046",
"0.5724786",
"0.5445473",
"0.53800493",
"0.53737646",
"0.53433657",
"0.53141534",
"0.5252366",
"0.52106875",
"0.52057683",
"0.5202676",
"0.515042",
"0.51475894",
"0.51414645",
"0.51303077",
"0.5116394",
"0.5103767",
"0.50991905",
"0.50... | 0.6521979 | 0 |
Assemble the option parser. | def initOpts():
option_list = [
make_option("-v", "--verbose",
action="store_true", dest="verbose", default=False,
help=""),
make_option("-l", "--licenses",
action="store", type="string", dest="licenses_xml",
help="Use the specified licenses file.",
default="licenses.xml"),
make_option("-o", "--output",
action="store", type="string", dest="output_rdf",
help="Write the RDF to the specified file.",
default=""),
]
usage = "%prog [-v] [-l licenses.xml] [-o output.rdf]"
parser = OptionParser(usage=usage,
version="%%prog %s" % __version__,
option_list = option_list)
return parser | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_parser(cls, option_group, args, mkflag):",
"def setup_parser(cls, option_group, args, mkflag):",
"def build_parser(self, parser: ArgumentParser) -> None:",
"def initCmdLineParser():\n\n # Init parser and all general flags\n logging.debug(\"initiating command line option parser\")\n usage =... | [
"0.7635837",
"0.7635837",
"0.7205048",
"0.71621025",
"0.7039156",
"0.7033386",
"0.702205",
"0.6990235",
"0.69513005",
"0.6902962",
"0.68967104",
"0.6892518",
"0.6840839",
"0.6837334",
"0.68262494",
"0.6812211",
"0.6810176",
"0.6762378",
"0.67567515",
"0.67565316",
"0.6741107"... | 0.6769619 | 17 |
Run the makerdf script. | def main():
optparser = initOpts()
(options, args) = optparser.parse_args()
output = StringIO.StringIO()
assembleRDF(file(options.licenses_xml), output, options.verbose)
if options.output_rdf:
file(options.output_rdf, 'w').write(output.getvalue())
else:
print output.getvalue() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main(): \n # Parse Arguments\n args = parse_arguments()\n\n # Print outdir\n print(\"Writing output to \" + args.outdir)\n\n # Print start statement\n print('Starting script for ' + args.file + ' at ' + str(datetime.datetime.now()), flush=True)\n\n # Put all the files in a function that w... | [
"0.67287403",
"0.63006973",
"0.6264529",
"0.6237319",
"0.6058982",
"0.60356236",
"0.59877056",
"0.59641856",
"0.59610593",
"0.59463936",
"0.5924916",
"0.59105444",
"0.59030676",
"0.5876134",
"0.585013",
"0.582454",
"0.58127964",
"0.5797604",
"0.5779497",
"0.5763903",
"0.57620... | 0.0 | -1 |
Returns the list of log paths that are not known by the log configuration associated to this instance | def get_new_logs(log_paths,log_conf):
if log_conf is None or log_conf.get_host() is None:
return log_paths
conf_logs = log_conf.get_host().get_logs()
new_logs = [log_path for log_path in log_paths if log_path not in conf_logs]
print 'New logs detected on %s: %s'(log_conf.get_host().get_name(), new_logs)
logger.info('New logs detected on %s: %s',log_conf.get_host().get_name(), new_logs)
return new_logs | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log_paths(self): # pylint:disable=function-redefined\n return self._log_paths",
"def all_logs(self):\n return os.listdir(LOGS_BASE_PATH)",
"def get_file_list_without_current_log():\n full_list = sorted(filter(os.path.isfile, os.listdir('.')), key=os.path.getmtime)\n full_list.remove(\"... | [
"0.8348011",
"0.6821954",
"0.6548825",
"0.64387006",
"0.6341025",
"0.6129678",
"0.6074887",
"0.6059957",
"0.605284",
"0.605284",
"0.60285383",
"0.60223985",
"0.5995747",
"0.5980469",
"0.59733",
"0.5953644",
"0.59462976",
"0.5943091",
"0.59387076",
"0.5936064",
"0.59292436",
... | 0.60559905 | 8 |
Returns the remote logging configuration or None if the remote configuration does not exist. | def get_instance_log_conf(instance_id):
# Retrieve current log config file
log_conf_file = None
filename = 'logentries_%s.conf'%instance_id
rsyslog_conf_name = '/etc/rsyslog.d/%s'%filename
local_conf_name = '/tmp/%s'%filename
# Clean file present
try:
local('rm %s'%local_conf_name)
except:
print 'Could not remove %s. It may not exist'%(local_conf_name)
logger.warning('Could not remove %s. It may not exist'%(local_conf_name))
# Get remote conf file or return None if it cannot be retrieved
try:
get(rsyslog_conf_name,local_conf_name)
except:
print '%s does not exist on instance %s'%(rsyslog_conf_name,instance_id)
logger.warning('%s does not exist on instance %s',rsyslog_conf_name,instance_id)
return None
# Open conf file or return None if it cannot be opened
try:
log_conf_file = open(local_conf_name,'r')
except:
print 'Cannot open %s from instance %s'%(local_conf_name,instance_id)
logger.warning('Cannot open %s from instance %s',local_conf_name,instance_id)
return None
return log_conf_file | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def logging_config(self) -> 'outputs.LoggingConfigResponse':\n return pulumi.get(self, \"logging_config\")",
"def logging_config(self) -> Optional['outputs.FeatureSpecFleetobservabilityLoggingConfig']:\n return pulumi.get(self, \"logging_config\")",
"def logging_config(self) -> Optional[pulumi.In... | [
"0.68369645",
"0.6830208",
"0.67188877",
"0.63710445",
"0.62929714",
"0.62837815",
"0.62123984",
"0.61937004",
"0.59980434",
"0.58134604",
"0.5746437",
"0.57139",
"0.5709636",
"0.56954515",
"0.5683042",
"0.5662481",
"0.5662481",
"0.564444",
"0.5639923",
"0.5633198",
"0.563116... | 0.5990378 | 9 |
Returns the updated log_conf, taking into account new log files present on the instance as well as modifications made to the corresponding logentries host. | def update_instance_conf(log_paths, log_conf):
log_client = LogClient.Client(account_key)
instance_id, config = get_ssh_config(env.host)
if log_conf is None and len(log_paths)>0:
print 'log_conf is None'
log_conf = create_host_logs(log_client,instance_id,log_paths)
elif log_conf is not None:
print 'log_conf is not None'
conf_host = log_conf.get_host()
if conf_host is None:
print 'Error. This instance configuration is missing the corresponding model!! instance_id=%s'%instance_id
logger.error('Error. This instance configuration is missing the corresponding model!! instance_id=%s',instance_id)
log_conf = create_host_logs(log_client,instance_id,log_paths)
return log_conf
if conf_host.get_key() is None:
print 'Host %s has an logentries-rsyslog config file but no account key!!'%host.get_name()
logger.warning('Host %s has an logentries-rsyslog config file but no account key!!',host.get_name())
log_conf = create_host_logs(log_client,instance_id,log_paths)
return log_conf
account = log_client.get_account()
matching_host = None
for host in account.get_hosts():
if host.get_key() == conf_host.get_key():
matching_host = host
break
# If there is no matching host, then it is assumed that it was deleted from Logentries and that no configuration should be associated to this instance.
if matching_host is None:
log_conf = create_host_logs(log_client,instance_id,log_paths)
return log_conf
for new_log in get_new_logs(log_paths, log_conf):
# Update matching host so that each new log becomes part of it.
matching_host = log_client.create_log_token(host=matching_host,log_name=new_log)
log_conf.set_host(matching_host)
return log_conf | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_instance_log_conf(instance_id):\n # Retrieve current log config file\n log_conf_file = None\n\n filename = 'logentries_%s.conf'%instance_id\n rsyslog_conf_name = '/etc/rsyslog.d/%s'%filename\n local_conf_name = '/tmp/%s'%filename\n \n # Clean file present\n try:\n local('rm %... | [
"0.7078796",
"0.6454262",
"0.6153468",
"0.609547",
"0.6065723",
"0.6051836",
"0.60207915",
"0.6019159",
"0.59815073",
"0.59241617",
"0.5814336",
"0.58045876",
"0.5802499",
"0.5684129",
"0.56608063",
"0.5597701",
"0.5580219",
"0.55438983",
"0.55438983",
"0.54896456",
"0.542672... | 0.77249867 | 0 |
Do lots of magic to make alembic work programmatically from the CLI. | def get_alembic_config(database_url: str) -> Config:
migrations_dir = os.path.dirname(os.path.abspath(__file__))
directory = os.path.join(migrations_dir, "migrations")
config = Config(os.path.join(migrations_dir, "alembic.ini"))
config.set_main_option("script_location", directory.replace("%", "%%"))
config.set_main_option("sqlalchemy.url", database_url)
return config | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main(arguments):\n migration = Migration(arguments)\n return migration.run()",
"def current():\n alembic_command.current(alembic_config, verbose=True)",
"def _init_db():\n import alembic.config\n import alembic.command\n alembic_cfg = alembic.config.Config('alembic.ini')\n alembic_cfg.... | [
"0.64835244",
"0.6423896",
"0.63449913",
"0.6249926",
"0.61865556",
"0.618295",
"0.6082049",
"0.5999133",
"0.59890723",
"0.5959365",
"0.5921134",
"0.58983696",
"0.5896638",
"0.5896638",
"0.5881768",
"0.58784425",
"0.58784425",
"0.5840882",
"0.58390534",
"0.5833645",
"0.583052... | 0.0 | -1 |
Runs the migrations and creates all of the database objects. | def init_db(database_url: str, fidesctl_config: FidesctlConfig) -> None:
alembic_config = get_alembic_config(database_url)
upgrade_db(alembic_config)
load_default_taxonomy(fidesctl_config) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_db():\n database.db.create_all()\n get_ulm()\n for fixture_file in glob.glob(config.DevelopmentConfig.FIXTURES_DIRS + '/*.json'):\n fixtures = JSONLoader().load(fixture_file)\n load_fixtures(database.db, fixtures)\n MigrationManager().stamp_db()",
"def db_create_all(self)... | [
"0.74945307",
"0.74615896",
"0.7393201",
"0.7345915",
"0.7331787",
"0.73113805",
"0.72740376",
"0.7251851",
"0.71819717",
"0.7157426",
"0.71482134",
"0.7122612",
"0.70904714",
"0.7079735",
"0.7049788",
"0.70419806",
"0.7040114",
"0.70348716",
"0.7018809",
"0.70154107",
"0.699... | 0.0 | -1 |
Drops all tables/metadata from the database. | def reset_db(database_url: str) -> None:
engine = get_db_engine(database_url)
connection = engine.connect()
SqlAlchemyBase.metadata.drop_all(connection)
migration_context = MigrationContext.configure(connection)
version = migration_context._version # pylint: disable=protected-access
if version.exists(connection):
version.drop(connection) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean_db():\n db = get_db()\n tables = db.tables\n for table in tables:\n db[table].drop()",
"def tear_down():\n db.flush()\n for table in metadata.tables.values():\n db.execute(table.delete())",
"def drop_tables() -> None:\n print(\"Dropping database tables usin... | [
"0.84615856",
"0.8291717",
"0.81522286",
"0.81405354",
"0.8026864",
"0.80001897",
"0.79949796",
"0.79896367",
"0.79855984",
"0.7966979",
"0.7918987",
"0.7878273",
"0.78614014",
"0.7860039",
"0.7847825",
"0.7836062",
"0.78076893",
"0.77844214",
"0.7772575",
"0.77703017",
"0.77... | 0.0 | -1 |
Epsilon is used here to avoid conditional code for checking that neither P nor Q is equal to 0. | def KL(P,Q):
epsilon = 0.00001
#You may want to instead make copies to avoid changing the np arrays.
P = P+epsilon
Q = Q+epsilon
divergence = np.sum(P*np.log(P/Q))
return divergence | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def epsilon():\n return _EPSILON",
"def get_initial_epsilon(self):\n return self.epsilon_percentile, True, self.max_rounds == 0",
"def epsilon(self):\n return self.__epsilon",
"def epsilon(self):\n return self._epsilon",
"def MccEpsilon(self):\n if getattr(self, '_MccEpsilon', ... | [
"0.71985364",
"0.6888928",
"0.6771035",
"0.6715826",
"0.6521258",
"0.64338565",
"0.63468957",
"0.63350797",
"0.6333442",
"0.6308612",
"0.62801576",
"0.6250783",
"0.62459266",
"0.6223243",
"0.6196995",
"0.6183421",
"0.61769325",
"0.6173163",
"0.61617094",
"0.61539805",
"0.6140... | 0.0 | -1 |
Returns the item with the highest valued key | def pop(self):
if len(self.heap)==0:
raise ValueError("Tried popping empty heap")
return heapq.heappop(self.heap)[1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def max_key(self):\n return self._price_list[-1]",
"def key_of_max(d):\n keys = list(d.keys())\n keys.sort()\n return max(keys, key=lambda x: d[x])",
"def keywithmaxval(d):\n\treturn max(d, key=lambda k: d[k])",
"def max_key (dict):\n output = -1\n for key, value in dict.items()... | [
"0.77251846",
"0.74479496",
"0.7443115",
"0.728091",
"0.7273358",
"0.72690016",
"0.7162577",
"0.7084611",
"0.706453",
"0.702705",
"0.69870156",
"0.69063205",
"0.69063205",
"0.69063205",
"0.6894217",
"0.68838924",
"0.687145",
"0.68680716",
"0.6850627",
"0.67813027",
"0.6753813... | 0.0 | -1 |
Given a normal feature matrix, creates a transpose feature matrix, a list of discrete features, and a list of nonempty features for each id. If the dataset is dense, this uses a Numpy matrix to save on space. Otherwise, it uses a listofdicts structure. | def __init__(self,db):
self._numFeatures = len(db.keys)
self._numEntries = len(db.entries)
numMissing = 0
if isinstance(db.entries[0],dict):
#already sparse database given as input
self.featureMatrix = None
self.featureDicts = [{} for i in range(self._numFeatures)]
self.discreteFeature = [True]*self._numFeatures
for i in xrange(self._numFeatures):
for j in xrange(self._numEntries):
if i in db.entries[j]:
v = db.entries[j][i]
if v != int(v):
self.discreteFeature[i] = False
break
self.entryLists = [[] for i in range(self._numFeatures)]
self.featureSets = []
for i in xrange(self._numEntries):
flist = []
for j in xrange(self._numFeatures):
if j in db.entries[i]:
flist.append(j)
self.entryLists[j].append(i)
self.featureDicts[j][i] = db.entries[i][j]
else:
numMissing += 1
self.featureSets.append(set(flist))
else:
featureMatrix = np.array(db.entries,dtype=np.float_)
self.featureMatrix = np.asfortranarray(featureMatrix).T
self.featureDicts = [{} for i in range(self._numFeatures)]
self.discreteFeature = []
for i in xrange(self.featureMatrix.shape[0]):
self.discreteFeature.append(not any(v != int(v) for v in self.featureMatrix[i,:] if not np.isnan(v)))
self.entryLists = [[] for i in range(self._numFeatures)]
self.featureSets = []
for i in xrange(self._numEntries):
flist = []
for j in xrange(self._numFeatures):
if not np.isnan(featureMatrix[i,j]):
flist.append(j)
self.entryLists[j].append(i)
self.featureDicts[j][i] = featureMatrix[i,j]
else:
numMissing += 1
self.featureSets.append(set(flist))
if numMissing == 0:
self.featureSets = None
self.featureDicts = None
else:
self.featureMatrix = None
self.sparsity = float(numMissing) / (self._numFeatures*self._numEntries) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preprocess_features(features):\n rowsum = np.array(features.sum(1))\n r_inv = np.power(rowsum, -1).flatten()\n r_inv[np.isinf(r_inv)] = 0.\n r_mat_inv = sp.diags(r_inv)\n features = r_mat_inv.dot(features)\n return features.todense(), sparse_to_tuple(features)",
"def preprocess_features(fea... | [
"0.5814003",
"0.5814003",
"0.5798338",
"0.5759967",
"0.5759967",
"0.5759362",
"0.5754472",
"0.56665456",
"0.56545",
"0.5584708",
"0.5582025",
"0.5555118",
"0.5517428",
"0.551733",
"0.5496943",
"0.54869235",
"0.5478383",
"0.5463325",
"0.5463325",
"0.54537517",
"0.5449544",
"... | 0.0 | -1 |
Given a dict, returns the key that has maximum value (arg max) | def argmax(table):
return max((v,k) for k,v in table.iteritems())[1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_max_key(dico):\n our_max = 0\n argmax = None\n for key, val in dico.items():\n if val > our_max:\n argmax = key\n our_max = val\n return argmax",
"def max_key (dict):\n output = -1\n for key, value in dict.items():\n output = max(output, k... | [
"0.86044014",
"0.85811913",
"0.85383964",
"0.8332157",
"0.8297145",
"0.82476956",
"0.8214348",
"0.8207442",
"0.8156642",
"0.81523865",
"0.8088131",
"0.8088131",
"0.8088131",
"0.80344087",
"0.7471879",
"0.7465998",
"0.74641794",
"0.74351037",
"0.7350328",
"0.73464257",
"0.7231... | 0.7673297 | 14 |
Given a distribution, given by the list p_list, returns the entropy of the distribution. | def entropy(p_list):
assert len(p_list) > 0
E = 0.0
for p in p_list:
if p == 0.0:
continue
E += p*math.log(p)
return E | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def entropy(l):\n\n probabilities = np.bincount(l) / len(l)\n with np.errstate(divide='ignore'): # ignore log(0) errors, we'll handle\n log_probabilities = np.log2(probabilities)\n log_probabilities[~np.isfinite(log_probabilities)] = 0\n return -np.sum(probabilities * log_probabilities)",
... | [
"0.75446194",
"0.73901826",
"0.7331276",
"0.7134225",
"0.70520824",
"0.7050444",
"0.69640076",
"0.6912087",
"0.68127155",
"0.68039405",
"0.6800982",
"0.6751854",
"0.6749378",
"0.6710503",
"0.6699265",
"0.6682273",
"0.6634976",
"0.6633226",
"0.6585759",
"0.6569177",
"0.6564183... | 0.83441865 | 0 |
For a list of dictionaries mapping values to counts, returns a cost used for DT splitting that is optimal at 0. Currently uses the negative of information gain. | def split_cost(label_count_list):
return -split_information_gain(label_count_list)
#this cost value is the misclassification error.
return split_misclassification_error(label_count_list) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cost(foods, foods_used):\n cost = 0.00\n for i, count in foods_used.items():\n cost += (foods[i]['serving_cost'] * count)\n return cost",
"def weighted_score(counters, lst, weight):\n if counters == None:\n counters = {}\n\n\n for item in lst:\n if item in counters:\n ... | [
"0.58399343",
"0.5823463",
"0.5779527",
"0.55471617",
"0.5469961",
"0.5425537",
"0.53996956",
"0.5383586",
"0.533916",
"0.5299643",
"0.52919436",
"0.5257763",
"0.52473646",
"0.52160746",
"0.52141124",
"0.52082145",
"0.51415884",
"0.5134601",
"0.5126979",
"0.5097489",
"0.50955... | 0.6280166 | 0 |
Given a list of values and associated labels, optimizes the best split threshold z where dividing the values into z has the lowest split cost. Returns a pair (z,cost) where cost is the split_cost of the threshold z. If nonelabels is given, this indicates the labels of missing values that must be passed down to both subtrees. This does not affect the output z but it does affect the output cost value. | def best_split(values,labels,nonelabels=None):
assert len(values) >= 2
assert len(values) == len(labels)
N = len(values)
ilist = sorted((v,l) for (v,l) in zip(values,labels))
leftcount = defaultdict(int)
rightcount = defaultdict(int)
for v,l in ilist:
rightcount[l] += 1
bestindex = -1
bestcost = split_cost([leftcount,rightcount])
cost = bestcost
#costs = [cost]
#print "Split costs:"
for i in xrange(len(ilist)):
v,l = ilist[i]
rightcount[l] -= 1
leftcount[l] += 1
if i+1 >= len(ilist) or v == ilist[i+1][0]:
#no splits when v is equal to the next value
continue
cost = split_cost([leftcount,rightcount])
#print " ",v,leftcount.values(),rightcount.values(),cost
#costs.append(cost)
if cost < bestcost:
bestcost = cost
bestindex = i
#raw_input()
if bestindex < 0:
#no split found... try splitting in half
splitval = (ilist[0][0]+ilist[-1][0])*0.5
else:
splitval = (ilist[bestindex][0] + ilist[bestindex+1][0])*0.5
if nonelabels is None:
return (splitval,bestcost)
#reevaluate counts
leftcount = defaultdict(int)
rightcount = defaultdict(int)
for l in nonelabels:
leftcount[l] += 1
rightcount[l] += 1
for v,l in ilist:
if v <= splitval:
leftcount[l] += 1
else:
rightcount[l] += 1
return splitval,split_cost([leftcount,rightcount]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def split_cost(label_count_list):\n return -split_information_gain(label_count_list)\n #this cost value is the misclassification error.\n return split_misclassification_error(label_count_list)",
"def pick_best_split(self,db,labels,ids,features=None):\n idlabels = [labels[id] for id in ids]\n ... | [
"0.6308325",
"0.60905",
"0.586987",
"0.5617052",
"0.5437539",
"0.5403514",
"0.5329129",
"0.52851343",
"0.52182657",
"0.51694614",
"0.5163954",
"0.5138482",
"0.5117913",
"0.5107134",
"0.5100632",
"0.5094282",
"0.50677717",
"0.50626785",
"0.50522244",
"0.5046674",
"0.50465786",... | 0.7924888 | 0 |
Normalizes an unnormalized histogram / probability distribution | def normalize(counts):
numvals = sum(counts.itervalues())
if numvals <= 0:
return counts
res = dict()
for (k,cnt) in counts.iteritems():
res[k] = float(cnt)/float(numvals)
return res | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalise_histogram(histogram):\n total_sum = np.sum(histogram)\n for i in range(len(histogram)):\n histogram[i] /= total_sum\n\n return histogram",
"def normalization(distribution):\r\n total_sum = 0\r\n for number in distribution.values():\r\n total_sum += number\r\n \r\... | [
"0.7903847",
"0.773003",
"0.76129586",
"0.73363006",
"0.724139",
"0.6925099",
"0.6923839",
"0.6893623",
"0.6813233",
"0.6747994",
"0.6707329",
"0.6559963",
"0.6552609",
"0.65408355",
"0.65334505",
"0.65331537",
"0.6515405",
"0.6507021",
"0.6436819",
"0.6389514",
"0.6374892",
... | 0.62111866 | 42 |
Predicts the label of the given entry. If it contains None elements (missing values), the return value is a probability distribution over possible outcomes (given by a dict). | def predict(self,entry):
if self.type == 'v':
return self.value
v = entry[self.feature]
if v is None:
#multiple childrens' predictions
counts = defaultdict(int)
labels = self.predict_all(entry,counts)
if len(counts) == 1:
return counts.keys()[0]
#return a probability distribution
return normalize(counts)
#maximum likelihood
#return argmax(counts)
if self.type == 's':
c = None
try:
c = self.children[v]
except KeyError:
#print "Unseen value for feature",self.feature,": ",v
best = None
bestDist = float('inf')
for (val,c) in self.children.iteritems():
if abs(val - v) < bestDist:
bestDist = abs(val - v)
best = c
c = best
return c.predict(entry)
elif self.type == 'i':
if v <= self.value:
return self.children[0].predict(entry)
else:
return self.children[1].predict(entry)
raise RuntimeError("Invalid DecisionTreeNode type?") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict(self, observation):\n\t\t# TODO - complete this\n\t\tp_max = 0\n\t\tpredict = None\n\t\tfor label in self.possible_labels:\n\t\t\tpossiblity = 1\n\t\t\tlabel_gaussian = self.gaussians.get(label)\n\t\t\tfor i in range(len(observation)):\n\t\t\t\t(mean, std) = label_gaussian[0][i]\n\t\t\t\tvalue = observ... | [
"0.6872355",
"0.6781801",
"0.66207117",
"0.64889395",
"0.6419287",
"0.64013904",
"0.63310605",
"0.6304575",
"0.62747353",
"0.62652564",
"0.6265103",
"0.62375915",
"0.61843824",
"0.617628",
"0.6124116",
"0.605304",
"0.60273445",
"0.60081005",
"0.5998837",
"0.59917265",
"0.5979... | 0.65727895 | 3 |
Looks up the leaf node corresponding to the given entry. Does not handle missing values. | def lookup(self,entry):
if self.type == 'v':
return self
v = entry[self.feature]
assert v != None
if self.type == 's':
c = None
try:
c = self.children[v]
except KeyError:
#print "Unseen value for feature",self.feature,": ",v
best = None
bestDist = float('inf')
for (val,c) in self.children.iteritems():
if abs(val - v) < bestDist:
bestDist = abs(val - v)
best = c
c = best
return c.lookup(entry)
elif self.type == 'i':
if v <= self.value:
return self.children[0].lookup(entry)
else:
return self.children[1].lookup(entry)
raise RuntimeError("Invalid DecisionTreeNode type?") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_parent_node(self, entry, key):\r\n parent = entry\r\n keys = key.split(\".\")\r\n for k in keys:\r\n try:\r\n parent = parent[k]\r\n except:\r\n raise Exception(\"key \\\"\" + key + \"\\\" was not found in HAR file\")\r\n retu... | [
"0.6321155",
"0.62434244",
"0.61522406",
"0.6018858",
"0.601176",
"0.6007655",
"0.59877974",
"0.5881265",
"0.5834447",
"0.5798371",
"0.57872856",
"0.5778088",
"0.57707995",
"0.5761493",
"0.57495886",
"0.57285845",
"0.57001275",
"0.56570214",
"0.56385493",
"0.5637989",
"0.5608... | 0.6669498 | 0 |
Given a indexed database db, a list of labels (one for each id), and a list of ids to test, sets this node to the best label. | def pick_best_label(self,db,labels,ids):
self.type = 'v'
if len(labels) > 0:
self.value = vote([labels[id] for id in ids])
else:
self.value = None
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def learn(self,db,labels):\n self.keys = db.keys[:]\n labelindex = -1\n if isinstance(labels,str):\n labelindex = db.keys.index(labels)\n assert labelindex >= 0,\"label does not exist in database keys\"\n labels = db.get_column(labelindex)\n elif isinsta... | [
"0.68891954",
"0.6300339",
"0.58898443",
"0.5635267",
"0.5226151",
"0.51870143",
"0.51595086",
"0.50911933",
"0.50677323",
"0.49870756",
"0.4969618",
"0.4949305",
"0.4914531",
"0.49075586",
"0.48753136",
"0.48677775",
"0.48287308",
"0.47792596",
"0.47701105",
"0.47633627",
"0... | 0.73168194 | 0 |
Given an index database db, a list of labels (one for each id), and a list of ids to train on, computes the optimal split value. It modifies this node to have the optimal split type and value, and then returns the quality of the split as computed by the split_cost function. If features != None, it is a list of available feature indices to use in this split, or a function of 0 arguments that can be called to get a list of features. | def pick_best_split(self,db,labels,ids,features=None):
idlabels = [labels[id] for id in ids]
if misclassification_error(idlabels) == 0:
#base case: no misclassifications
self.type = 'v'
self.value = idlabels[0]
return 0
best = None
bestCost = 0
splitval = None
discrete = True
if features == None:
if len(ids) < db.numFeatures():
#look at all present features in the training set
features = db.getPresentFeatures(ids)
#print len(features),"of",db.numFeatures(),"features selected"
else:
features = range(db.numFeatures())
elif callable(features):
features = features()
for i in features:
if len(db.entryLists[i]) == 0: continue
idiscrete = db.discreteFeature[i]
if idiscrete:
#count number of labels of a certain value
splitter = defaultdict(lambda:defaultdict(int))
#count of labels for missing values
nmissing = defaultdict(int)
for id in ids:
val = db[i,id]
if val is None:
#missing values go down to all splits
nmissing[labels[id]] += 1
continue
splitter[val][labels[id]] += 1
if len(splitter) > continuous_variable_threshold:
#print "Determined to be a continuous variable"
idiscrete = False
break
if idiscrete:
if len(splitter) <= 1:
#only a single value
continue
#count number of missing values in all splits
cmax = 0
for k in splitter:
for l,v in nmissing.iteritems():
splitter[k][l] += v
cmax = max(cmax,sum(splitter[k].values()))
#shrink by fraction of (# of ids - largest child)/(# of ids)
scale = (1.0-float(cmax)/float(len(ids)))*len(splitter)
#evaluate cost
cost = split_cost(splitter.values())*scale
#print "Split on",i,"information gain",-cost,splitter.values()
else:
#continuous, need to learn the best split
vals = []
presentlabels = []
nonelabels = []
for id in ids:
val = db[i,id]
if val is None:
nonelabels.append(labels[id])
continue
vals.append(val)
presentlabels.append(labels[id])
if len(vals) <= 1:
print "No values for feature",i,"?"
print vals
continue
#print "Considering continuous split on",i
s,cost = best_split(vals,presentlabels,nonelabels)
scale = (1.0-float(len(presentlabels)/2+len(nonelabels))/float(len(ids)))*2
cost *= scale
#print "Result",s,"Information gain",-cost
if cost < bestCost:
best = i
bestCost = cost
discrete = idiscrete
if not idiscrete:
splitval = s
if best is None:
self.type = 'v'
if len(ids) > 0:
self.value = vote(idlabels)
return misclassification_error(idlabels)
else:
self.value = None
return 0
else:
self.feature = best
#discrete or inequality split
if discrete:
self.type = 's'
else:
self.type = 'i'
self.value = splitval
return bestCost | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __get_split_feature(self, data_set, target_feature, tree_features):\n\n if self.__criterion == 'entropy':\n feature_gains = {feature: self.__gain(data_set, feature, target_feature) for (feature) in tree_features}\n split_feature = max(feature_gains, key=feature_gains.get)\n ... | [
"0.59855705",
"0.57539624",
"0.5735463",
"0.57259667",
"0.5551452",
"0.55483556",
"0.5174804",
"0.5155585",
"0.5107157",
"0.50866544",
"0.50679135",
"0.5035721",
"0.50326467",
"0.5029078",
"0.50207394",
"0.4985602",
"0.49575225",
"0.4956578",
"0.4938984",
"0.49286735",
"0.490... | 0.7983181 | 0 |
Computes counts for ALL compatible predictions for the given entry, taking missing values into account. counts is assumed to be a defaultdict(int) instance | def predict_all(self,entry,counts):
if self.type == 'v':
counts[self.value] += 1
return
v = entry[self.feature]
if v is None:
for val,c in self.children.iteritems():
c.predict_all(entry,counts)
return
if self.type == 's':
c = None
try:
c = self.children[v]
except KeyError:
#print "Unseen value for feature",self.feature,": ",v
best = None
bestDist = float('inf')
for (val,c) in self.children.iteritems():
if abs(val - v) < bestDist:
bestDist = abs(val - v)
best = c
c = best
c.predict_all(entry,counts)
elif self.type == 'i':
if v <= self.value:
self.children[0].predict_all(entry,counts)
else:
self.children[1].predict_all(entry,counts)
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def none_count(d):\n return six.moves.reduce(lambda x, y: x + 1 if y == None else x, d.values(), 0)",
"def _collect_counts(self, instance_list):\n \"\"\" Based on each instance, I augment empirical counts for every word and its BIO label in feature_count_table and for every transition from previous lab... | [
"0.627431",
"0.6079571",
"0.5920963",
"0.5891744",
"0.5813785",
"0.5808457",
"0.57633555",
"0.5717828",
"0.5693999",
"0.5685904",
"0.5680773",
"0.5613226",
"0.55953914",
"0.5592989",
"0.5554436",
"0.5554436",
"0.5554436",
"0.5552211",
"0.5529736",
"0.55194706",
"0.55182385",
... | 0.5712293 | 8 |
Predicts a label for a feature vector | def predict(self,entry):
assert self.root is not None,"Decision tree is not initialized"
return self.root.predict(entry) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict(self, features):\n vec = vectorize(features, self.vocab,\n self.dpvocab, self.projmat)\n label = self.clf.predict(vec)\n # print label\n return self.labelmap[label[0]]",
"def predict_label(self, src): # real signature unknown; restored from __doc__\n... | [
"0.7951119",
"0.77826697",
"0.745595",
"0.745595",
"0.745595",
"0.7453583",
"0.7453583",
"0.74425894",
"0.74354345",
"0.73819107",
"0.73819107",
"0.73819107",
"0.73376524",
"0.7261632",
"0.72183657",
"0.721681",
"0.7200597",
"0.7177909",
"0.71714",
"0.71003073",
"0.709932",
... | 0.0 | -1 |
Learns from a Database instance. Each entry is given a label. | def learn(self,db,labels):
self.keys = db.keys[:]
labelindex = -1
if isinstance(labels,str):
labelindex = db.keys.index(labels)
assert labelindex >= 0,"label does not exist in database keys"
labels = db.get_column(labelindex)
elif isinstance(labels,int):
labelindex = labels
labels = db.get_column(labelindex)
else:
assert len(labels) == len(db.entries)
self.root = DecisionTreeNode()
if labelindex >= 0:
raise NotImplementedError("Ooops, taking out indexed label broken")
entries = np.delete(entries,labelindex,1)
db = IndexedDatabase(db)
if self.maxnodes != None:
return self.greedy_learn_search(db,labels)
else:
self.deepest = 0
return self.greedy_learn(self.root,db,labels,range(len(labels))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_data_to_db(labelled):\n add_query = sqlite3.connect(DB_PATH).cursor()\n add_query.execute(\n \"CREATE TABLE IF NOT EXISTS labels(text TEXT, label TEXT, score FLOAT)\")\n for entry in labelled:\n add_query.execute(\"\"\"INSERT INTO labels(text,label,score) VALUES(?,?,?)\"\"\",\n ... | [
"0.607027",
"0.5603955",
"0.52142614",
"0.51333624",
"0.51184493",
"0.5110511",
"0.50444543",
"0.50385123",
"0.50106204",
"0.50006604",
"0.49866673",
"0.49164563",
"0.48594052",
"0.48593736",
"0.48549092",
"0.48429736",
"0.4827033",
"0.48192468",
"0.4811291",
"0.48048383",
"0... | 0.6163972 | 0 |
Returns the maximum depth of the tree | def depth(self):
return max(n.depth for n in self.iternodes()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def max_tree_depth(self):\n\n depths = np.array([leaf.tree_depth for leaf in self.leaves])\n\n return depths.max()",
"def _max_depth(self):\n max_depth = 0\n for node, data in self.traverse():\n max_depth = max(max_depth, data['level'])\n return max_depth",
"def ma... | [
"0.88220024",
"0.8809473",
"0.8737049",
"0.8678075",
"0.8640208",
"0.84385777",
"0.84369",
"0.82397825",
"0.8233229",
"0.8227665",
"0.82105106",
"0.8154944",
"0.8108934",
"0.80783707",
"0.8075165",
"0.7958314",
"0.7903902",
"0.7895258",
"0.78915644",
"0.7854622",
"0.7788676",... | 0.8212468 | 10 |
Returns the total number of nodes in the tree | def numNodes(self):
res = 0
for n in self.iternodes():
res += 1
return res | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count(self):\n return self.__tree.node_count",
"def count_nodes(self):\n if self.children is None:\n return 0\n\n total_count = 0\n for child in self.children:\n if child is None:\n return 0\n child_count = child.count_nodes()\n ... | [
"0.85499597",
"0.8500708",
"0.84604555",
"0.84518975",
"0.8407748",
"0.83981884",
"0.8378013",
"0.832748",
"0.83060443",
"0.826005",
"0.81602746",
"0.81444424",
"0.81200975",
"0.808973",
"0.80409694",
"0.8024372",
"0.8013639",
"0.800769",
"0.800769",
"0.79400194",
"0.7878856"... | 0.83307356 | 7 |
Returns all nodes in the tree | def nodes(self):
return [n for n in self.iternodes()] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_nodes(self):\n return self._get_all_nodes()",
"def get_nodes(self):\n all_nodes = [] \n if not self._root is None:\n all_nodes.append(self._root)\n i = 0\n while i < len(all_nodes):\n for node in all_nodes[i]._children:\n ... | [
"0.8067358",
"0.805089",
"0.80140465",
"0.7930633",
"0.7844008",
"0.7699735",
"0.766375",
"0.7651623",
"0.7554823",
"0.74022615",
"0.73905694",
"0.73905694",
"0.72834",
"0.7274381",
"0.7274381",
"0.7274381",
"0.72736555",
"0.7273303",
"0.7249022",
"0.7241052",
"0.7209985",
... | 0.7894537 | 4 |
Pretty prints the tree | def pprint(self,indent=0,node=None):
if node == None:
node = self.root
if node == None:
print_indent(indent)
print "[empty tree]"
return
if node.type == 'v':
print_indent(indent)
print node.value
elif node.type == 's':
for (val,c) in node.children.iteritems():
print_indent(indent)
print "-",self.keys[node.feature],"=",val,":"
self.pprint(indent+1,c)
elif node.type == 'i':
print_indent(indent)
print self.keys[node.feature],"<=",node.value,":"
self.pprint(indent+1,node.children[0])
print_indent(indent)
print self.keys[node.feature],">",node.value,":"
self.pprint(indent+1,node.children[1]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_tree(self):\n\t\tprint(self.__print_tree('', True, ''))",
"def pprint(tree):\n p = PrettyPrinter(indent=2)\n p.pprint(tree)",
"def print_tree(self):\n return \"\"",
"def printTree(self):\n print(printTreeF(self, 0, self))",
"def pretty_print(self):\n return self... | [
"0.85880834",
"0.8403361",
"0.81731063",
"0.81423867",
"0.813626",
"0.8090559",
"0.8077962",
"0.80575883",
"0.8041075",
"0.7977933",
"0.79050046",
"0.7841601",
"0.78335243",
"0.7790531",
"0.77501893",
"0.77443475",
"0.7728508",
"0.7723257",
"0.7723172",
"0.7723172",
"0.771828... | 0.7580208 | 24 |
Can overload this to choose different features | def feature_subset(self,node,db,labels,ids):
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def feature():\n pass",
"def support(self):",
"def feat():\n pass",
"def feature(self):\n Feature(run=default_frame, flags=TE)\n Feature(run=load(\"window_functions.tests.rows_frame\", \"feature\"), flags=TE)\n Feature(run=load(\"window_functions.tests.range_frame\", \"feature\"), flags=TE)\n ... | [
"0.72120637",
"0.6650957",
"0.6531752",
"0.63173395",
"0.630279",
"0.62784165",
"0.62421846",
"0.62280315",
"0.6188825",
"0.6120786",
"0.61044574",
"0.6051126",
"0.5929795",
"0.5882283",
"0.5840704",
"0.57487196",
"0.5733037",
"0.5721487",
"0.57165647",
"0.56840765",
"0.56801... | 0.0 | -1 |
Given a indexed database, greedily and recursively learns the split value for the subtree of the indicated node. Return value is the number of mistakes made by the decision tree. Missing values are handled properly as indicating a 'don't care' value that gets passed down to both sides of the tree. | def greedy_learn(self,node,db,labels,ids):
if node.depth >= self.maxdepth or len(ids) <= self.minexamples:
#terminate recursion
node.pick_best_label(db,labels,ids)
err = misclassification_error([labels[id] for id in ids])
if err > 0:
print "Reached a leaf and had to make some sacrifices, cost",err
print " depth",node.depth
print " labels",[labels[id] for id in ids]
return err
features = self.feature_subset(node,db,labels,ids)
cost = node.pick_best_split(db,labels,ids,features)
#do a split
if node.type == 'v':
#base case: no misclassifications
"""
if cost>0:
print "greedy_learn: Warning, pick_best_split indicates a leaf but the cost is nonzero"
print "cost=",cost,"misclassification=",misclassification_error([labels[id] for id in ids])
print "# of ids:",len(ids)
for i in ids:
print "id",i,",",
for k in range(db.numFeatures()):
if db[k,i] != None:
print k,"=",db[k,i],",",
print "label",labels[i]
raw_input()
"""
return 0
elif node.type == 's':
#print "Picked feature",node.feature,"split"
#do a discrete split
node.children = dict()
#select sub-indices
Eids = defaultdict(list)
noneids = []
for id in ids:
v = db[node.feature,id]
if v is None:
#item doesn't exist, it's a missing value
noneids.append(id)
else:
Eids[v].append(id)
#print " split sizes:",[len(x) for x in Eids.values()]
#print " None ids:",len(noneids)
ids = None
errors = 0
for v,vids in Eids.iteritems():
#recurse
c = DecisionTreeNode(node)
#print "Recursing on value",v
#print " ids:",vids
errors += self.greedy_learn(c,db,labels,vids+noneids)
node.children[v] = c
if c.depth > self.deepest:
self.deepest = c.depth
print "Decision tree learner: Reached node with depth",self.deepest
return errors
else:
#do an inequality split
assert node.type == 'i'
#print "Picked feature",node.feature,"inequality value",node.value,"cost",cost
leftids = []
rightids = []
for id in ids:
if db[node.feature,id] is not None:
if db[node.feature,id] <= node.value: leftids.append(id)
else: rightids.append(id)
else:
leftids.append(id)
rightids.append(id)
if len(rightids) == len(ids) or len(leftids) == len(ids):
#due to missing values, this split is useless
errors = misclassification_error([labels[id] for id in ids])
print "useless split on feature",node.feature,"value",node.value,"misclassification error",errors
print "Left size",len(leftids),"right size",len(rightids)
raw_input()
node.pick_best_label(db,labels,ids)
return errors
#clear memory associated with ids list
del ids[:]
ids = None
#print "Left size",len(leftids),"right size",len(rightids)
c1 = DecisionTreeNode(node)
c2 = DecisionTreeNode(node)
#left side
errors = self.greedy_learn(c1,db,labels,leftids)
#right side
errors += self.greedy_learn(c2,db,labels,rightids)
#restore index
node.children = {0:c1,1:c2}
if c1.depth > self.deepest:
self.deepest = c1.depth
print "Decision tree learner: Reached node with depth",self.deepest
return errors | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluate_split( df, attribute, split ):\n mask = df[attribute] <= split\n \n # split the dataset on the split attribute\n dfl = df[mask]\n dfr = df[~mask]\n \n \n # calculate weighting factors for child\n weighting_factor_left = float(dfl.shape[0])/df.shape[0]\n weighting_factor_ri... | [
"0.55779785",
"0.5408219",
"0.5375125",
"0.52919394",
"0.5285259",
"0.5265397",
"0.523007",
"0.5206214",
"0.5131763",
"0.5119118",
"0.5102969",
"0.50822806",
"0.50254524",
"0.50055486",
"0.5000578",
"0.498862",
"0.49706918",
"0.4968559",
"0.49658915",
"0.49245366",
"0.4886081... | 0.5963019 | 0 |
Identifies the list of example indices that would follow the decision tree to node. | def identify_examples(self,db,labels,node):
path = []
while node.parent != None:
nkey = None
for (k,c) in node.parent().children.iteritems():
if c is node:
nkey = k
break
assert nkey != None
path.append((node.parent(),nkey))
node = node.parent()
path = path[::-1]
nids = len(labels)
ids = []
for id in xrange(nids):
valid = True
for n,ckey in path:
f = n.feature
val = featureMatrix[f,id]
if val is None:
#it's a None value, just continue on
continue
else:
key = None
if n.type == 'i':
key = (0 if val <= n.value else 1)
else:
key = val
if key != ckey:
valid = False
break
if valid:
ids.append(id)
return ids | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def target_nodes_indexes(self) -> _TargetNodes:\n return self.__target_nodes_indexes",
"def reference_nodes_idx(self) -> Dict[str, torch.Tensor]:\n return self.node_idx_references",
"def get_34index_list(self):\n msk = self.load_mask()\n return [i for (i,v) in enumerate(msk) if v==1... | [
"0.65589315",
"0.63866156",
"0.6244448",
"0.6186481",
"0.60354745",
"0.5978617",
"0.5964173",
"0.5956777",
"0.589274",
"0.5866264",
"0.58425367",
"0.58398837",
"0.58153033",
"0.58101755",
"0.58045644",
"0.57759035",
"0.57590544",
"0.57380056",
"0.57340384",
"0.5718878",
"0.57... | 0.68075645 | 0 |
Same as greedy learn, but with a maximum number of nodes. Rather than a DFS, this uses a priority queue that at each step splits the node with the maximum improvement in misclassification error. At most maxnodes are in the resulting tree, and the depth is limited to maxdepth. Returns the total number of misclassifications of the training set. There is a lowmemory mode when self.lowmem == True or self.lowmem == 'auto' and the number of saved ids at a node grows beyond a certain number (self.lowmem_threshold, 10m by default). In lowmemory mode, the subset of of examples at a given node is determined dynamically, which incurs a O(|D|d) cost per node, where d is the depth of the node. Overall this raises running time by a factor of approximately O(|D| log_2 |D|). | def greedy_learn_search(self,db,labels):
queue = PriorityQueue()
dolowmem = (self.lowmem == True)
numidsets = 0
root_ids = range(len(labels))
queue.push((self.root,root_ids),len(labels))
numnodes = 1
deepest = 0
err = 0
while len(queue) > 0 and numnodes+2 <= self.maxnodes:
#print "%d nodes, priority %d"%(numnodes,queue.nextkey())
nerr = queue.nextkey()
(node,trainingset) = queue.pop()
#print "Greedy learn",len(trainingset)
if trainingset is None:
trainingset = self.identify_examples(db,labels,node)
if node.depth >= self.maxdepth or len(trainingset) <= self.minexamples:
#print " Hit depth or training set limit"
node.pick_best_label(db,labels,trainingset)
err += misclassification_error([labels[id] for id in trainingset])
continue
features = self.feature_subset(node,db,labels,trainingset)
cost = node.pick_best_split(db,labels,trainingset,features)
numidsets -= len(trainingset)
#do a split
if node.type == 'v':
continue
elif node.type == 's':
#discrete split
node.children = dict()
#select sub-indices
Eids = defaultdict(list)
noneids = []
for id in trainingset:
v = db[node.feature,id]
if v is None:
#item doesn't exist, it's a missing value
noneids.append(id)
else:
Eids[v].append(id)
#determine whether to switch to low-memory mode
if not dolowmem and self.lowmem=='auto':
for v,vids in Eids.iteritems():
numidsets += len(vids)+len(noneids)
if numidsets > self.lowmem_threshold:
print "Decision tree learner switching to low-memory mode"
dolowmem = True
trainingset = None
numnodes += len(Eids)
#print "Split sizes",[len(v) for v in Eids.itervalues()]
#print "None size",len(noneids)
for v,vids in Eids.iteritems():
#print "->",len(vids),"+",len(noneids)
#recurse
c = DecisionTreeNode(node)
node.children[v] = c
err = misclassification_error([labels[id] for id in vids+noneids])
cids = (None if dolowmem else vids+noneids)
queue.push((c,cids),err)
if c.depth > deepest:
deepest = c.depth
print "Decision tree learner: Reached node with depth",deepest
else:
#do an inequality split
assert node.type == 'i',"Got a weird type? "+str(node.type)
leftids = []
rightids = []
for id in trainingset:
val = db[node.feature,id]
if val is not None:
if val <= node.value: leftids.append(id)
else: rightids.append(id)
else:
leftids.append(id)
rightids.append(id)
if len(leftids)==0 or len(rightids)==0:
print "node feature "+str(node.feature)+" doesn't have a valid split value "+str(node.value)
vals = [db[node.feature,id] for id in trainingset if db[node.feature,id]!=None]
print "min,max of training set:",min(vals),max(vals)
print "cost is",cost
raw_input()
assert len(leftids) > 0 and len(rightids) > 0
if not dolowmem and self.lowmem=='auto':
numidsets += len(leftids) + len(rightids)
if numidsets > self.lowmem_threshold:
print "Decision tree learner switching to low-memory mode"
dolowmem = True
trainingset = None
numnodes += 2
c1 = DecisionTreeNode(node)
c2 = DecisionTreeNode(node)
node.children = {0:c1,1:c2}
#print "->",len(leftids)
#print "->",len(rightids)
err1 = misclassification_error([labels[id] for id in leftids])
err2 = misclassification_error([labels[id] for id in rightids])
if dolowmem:
leftids = None
rightids = None
queue.push((c1,leftids),err1)
queue.push((c2,rightids),err2)
if c1.depth > deepest:
deepest = c1.depth
print "Decision tree learner: Reached node with depth",deepest
#end of recursion. for the rest of the nodes still in the queue, make them leaf nodes
if len(queue) > 0:
print "%d nodes remaining in queue, setting to leaves"%(len(queue),)
for (node,trainingset) in queue:
node.pick_best_label(db,labels,trainingset)
err += misclassification_error([labels[id] for id in trainingset])
return err | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def node_count_max(self) -> int:\n return int(self.graph_tuple_stats.node_count_max or 0)",
"def max_node_count(self) -> int:\n return pulumi.get(self, \"max_node_count\")",
"def max_node_count(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"max_node_count\")",
"def max_nod... | [
"0.6156422",
"0.6155967",
"0.59827256",
"0.5911448",
"0.5853999",
"0.583166",
"0.5827011",
"0.5772355",
"0.5760408",
"0.570417",
"0.5690565",
"0.5642428",
"0.55889016",
"0.556948",
"0.5526726",
"0.5512847",
"0.5484053",
"0.54723763",
"0.54671174",
"0.5442169",
"0.54306436",
... | 0.62972176 | 0 |
Initializes the list. If entries is given, this initializes the entries of the list. If memoized = True, any lazy evaluated entries are saved after their first evaluation. | def __init__(self,entries=None,memoized=False):
if entries is not None:
self.entries = entries[:]
else:
self.entries = []
self.memoized = memoized | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, contents=()):\n self._data = [self._Item(k, v) for k,v in contents] # empty by default\n if len(self._data) > 1:\n self._heapify()",
"def init_all_entries(self) -> bool:\n raise NotImplementedError",
"def __init__(self, owner, entries=None):\n\n self.o... | [
"0.5535386",
"0.54829353",
"0.5454826",
"0.53897613",
"0.5307603",
"0.5187028",
"0.5180785",
"0.514409",
"0.50772923",
"0.5034808",
"0.5021943",
"0.5018495",
"0.49956906",
"0.49621394",
"0.49150985",
"0.49012715",
"0.4892579",
"0.48834223",
"0.48831782",
"0.48757192",
"0.4859... | 0.7950624 | 0 |
Given a training and testing dataset, builds a decision tree and tests it | def test_decision_tree(train,test,maxnodes=None):
tree = DecisionTree()
tree.maxnodes = maxnodes
errors = tree.learn(train,'label')
print "Decision tree makes",errors,"errors"
print "Depth",tree.depth(),"nodes",tree.numNodes()
if tree.numNodes() < 100:
tree.pprint()
if errors > 0:
print "Training errors:"
for id,e in enumerate(train.entries):
res = tree.predict(e[:-1])
if res != e[-1]:
if len(e[:-1]) > 10:
print " Error on",id,"prediction",res
else:
print " Error on",e[:-1],"prediction",res
print "Testing error:"
tp,tn,fp,fn = 0,0,0,0
for e in test.entries:
res = tree.predict(e[:-1])
if res and e[-1]:
tp += 1
elif res and not e[-1]:
fp += 1
elif not res and e[-1]:
fn += 1
else:
tn += 1
Ntest = len(test.entries)
print "True +: %g, True -: %g"%(float(tp)/Ntest,float(tn)/Ntest)
print "False -: %g, False +: %g"%(float(fn)/Ntest,float(fp)/Ntest)
print "Overall error: %g"%(float(fn+fp)/Ntest,) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train_and_evaluate_decision_tree(X_train, y_train, X_test, y_test):\n model = DecisionTreeClassifier(criterion='entropy')\n model.fit(X_train, y_train)\n y_pred = model.predict(X_train)\n y_heldPred = model.predict(X_test)\n acc_train = accuracy_score(y_train, y_pred)\n acc_heldOut = accuracy... | [
"0.71724963",
"0.6940502",
"0.6876765",
"0.6875179",
"0.68419737",
"0.68007624",
"0.671924",
"0.6693489",
"0.6642988",
"0.6619835",
"0.657808",
"0.6437057",
"0.6418784",
"0.63988245",
"0.6392599",
"0.63923985",
"0.6373904",
"0.63466936",
"0.6346446",
"0.6345242",
"0.63415146"... | 0.6959578 | 1 |
Test the template tag js_settings | def test_js_settings(mocker, rf):
mocker.patch(
"mitxpro.templatetags.js_interop.get_js_settings",
return_value={"data": "value"},
)
request = rf.get("/")
context = Context({"request": request})
template = Template(("{% load js_interop %}" "{% js_settings %}"))
rendered_template = template.render(context)
assert (
rendered_template
== """<script type="text/javascript">
var SETTINGS = {"data": "value"};
</script>"""
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def jssettings(self):\n self.update()\n return \"var %s = %s\" % (self.js_var_settings_name,\n json.dumps(self.settings))",
"def test_jssettings(self):\n settings_fullpath = os.path.join(dirs.get_main_js_dir(), \"mediabrute-settings.js\")\n \n i... | [
"0.6923433",
"0.6532566",
"0.6531576",
"0.6457588",
"0.6457588",
"0.6105654",
"0.6031209",
"0.60102826",
"0.5945879",
"0.5761625",
"0.57324207",
"0.5658938",
"0.5633526",
"0.5626261",
"0.5626261",
"0.55889726",
"0.5578439",
"0.5576125",
"0.5567976",
"0.5524449",
"0.54723006",... | 0.8117115 | 0 |
Uses keypoint algorithm SIFT to extract feature points from the image and get point correspondences | def getFeatureMatches(img1, img2):
sift = xfeatures2d.SIFT_create()
kp1, des1 = sift.detectAndCompute(img1, None)
kp2, des2 = sift.detectAndCompute(img2, None)
FLANN_INDEX_KDTREE = 0
index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5)
search_params = dict(checks=50)
flann = cv2.FlannBasedMatcher(index_params, search_params)
matches = flann.knnMatch(des1, des2, k=2)
Left_Pts = list()
Right_Pts = list()
# Ratio criteria according to Lowe's paper
for i, (m, n) in enumerate(matches):
if m.distance < 0.5 * n.distance:
Left_Pts.append(kp1[m.queryIdx].pt)
Right_Pts.append(kp2[m.trainIdx].pt)
left = np.array(Left_Pts)
right = np.array(Right_Pts)
features = (left, right)
return features | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def SIFT_features(self):\n start_time = datetime.datetime.now() \n self.func_log(\"\\n\\tIn SIFT_features()\")\n \n key_points = {}\n descriptor_list = []\n SIFT = cv2.xfeatures2d.SIFT_create()\n \n self.func_log(\"\\t\\tSIFT feature extrac... | [
"0.75240153",
"0.7496029",
"0.7456625",
"0.73814374",
"0.7321232",
"0.7184007",
"0.7014539",
"0.6925322",
"0.68039143",
"0.6791409",
"0.6788328",
"0.6726114",
"0.66914046",
"0.66845495",
"0.66036594",
"0.6586292",
"0.6563133",
"0.6560529",
"0.6559361",
"0.65400463",
"0.644459... | 0.67450947 | 11 |
This function computes the fundamental matrix by computing the SVD of Ax = 0 ; 8point algorithm | def computeFundamentalMatrix(pts1, pts2):
A = np.empty((8, 9))
for i in range(len(pts1)-1):
x1 = pts1[i][0]
x2 = pts2[i][0]
y1 = pts1[i][1]
y2 = pts2[i][1]
A[i] = np.array([x1 * x2, x2 * y1, x2,
y2 * x1, y2 * y1, y2,
x1, y1, 1])
# Compute F matrix by evaluating SVD
U, S, V = np.linalg.svd(A)
F = V[-1].reshape(3, 3)
# Constrain the F matrix to rank 2
U1, S1, V1 = np.linalg.svd(F)
# print('Old S', S)
# S[2] = 0
S2 = np.array([[S1[0], 0, 0], [0, S1[1], 0], [0, 0, 0]])
# print('New S', S)
F = np.dot(np.dot(U1, S2), V1)
return F | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def svd0(A):\n M,N = A.shape\n if M>N: return sla.svd(A, full_matrices=True)\n else: return sla.svd(A, full_matrices=False)",
"def invert_L1_svd():",
"def visualize_svd():",
"def svd(self):\n U, s, Vh = la.svd(self)\n S = np.zeros(self.shape)\n np.fill_diagonal(S, s)\n return... | [
"0.66048837",
"0.6466162",
"0.6259937",
"0.6250825",
"0.62505597",
"0.62274474",
"0.6104567",
"0.6089218",
"0.6025379",
"0.5982765",
"0.597328",
"0.590215",
"0.58907986",
"0.58582675",
"0.58575904",
"0.584388",
"0.58408606",
"0.58376825",
"0.581499",
"0.58008623",
"0.5792866"... | 0.68444854 | 0 |
Leverages the 8point algorithm and implement RANSAC algorithm to find the inliers and the best fundamental matrix | def getInlierRANSAC(pts1, pts2):
# global finalFundamentalMatrix
iterations = 50
threshold = 0.01
max_count = 0
n = len(pts1)
finalFundamentalMatrix = np.zeros((3, 3))
for i in range(iterations):
count = 0
idx = random.sample(range(n - 1), 8)
left_pts = pts1[idx]
right_pts = pts2[idx]
F = computeFundamentalMatrix(left_pts, right_pts)
left_feature_inlier = []
right_feature_inlier = []
# print("Sample index: ", len(idx))
for j in range(0, n):
homogeneous_right = np.array([pts2[j, 0], pts2[j, 1], 1])
homogeneous_left = np.array([pts1[j, 0], pts1[j, 1], 1])
fit = np.dot(homogeneous_right.T, np.dot(F, homogeneous_left))
# print("Fit for iteration ", i," ", np.abs(fit))
if np.abs(fit) < threshold:
left_feature_inlier.append(pts1[j])
right_feature_inlier.append(pts2[j])
count = count + 1
# print('Inlier count', count)
inlier_Left = np.array(left_feature_inlier)
inlier_Right = np.array(right_feature_inlier)
if count > max_count:
max_count = count
finalFundamentalMatrix = F
final_inlier_Left = inlier_Left
final_inlier_Right = inlier_Right
return finalFundamentalMatrix, final_inlier_Left, final_inlier_Right | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ransac(data, hypothesis, metric, sample_size, num_iter, inlier_thresh):\n N,d = data.shape\n best_frac, best_hypothesis, best_mask = 0, None, None\n for i in range(num_iter):\n js = np.random.choice(N,size=sample_size,replace=False)\n hypothesis_elements = data[js,:]\n H = hypothe... | [
"0.6203597",
"0.5916464",
"0.5894118",
"0.5867515",
"0.5715989",
"0.56956524",
"0.56905115",
"0.5686345",
"0.56403846",
"0.55984086",
"0.5590803",
"0.5577823",
"0.5559308",
"0.5542196",
"0.5525735",
"0.55202436",
"0.55189615",
"0.55174667",
"0.5481329",
"0.5479639",
"0.546803... | 0.699575 | 0 |
This function computes the essential matrix from the fundamental matrix. The E matrix is defined in normalized image coordinates | def getEssentialMatrix(K, F):
E = np.dot(K.T, np.dot(F, K))
u, s, v = np.linalg.svd(E)
# We correct the singular values of the E matrix
s_new = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 0]]).reshape(3, 3)
final_E = np.dot(u, np.dot(s_new, v))
return final_E | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def eigen_decomp(matrix):\n w = None\n v = None\n ### YOUR CODE HERE\n w,v=np.linalg.eig(matrix)\n ### END YOUR CODE\n return w, v",
"def P(self):\n self.eigenmatrix()",
"def Euler2Mat(e):\n x=e[0]\n y=e[1]\n z=e[2]\n s1=np.sin(x)\n s2=np.sin(y)\n s3=np.sin(z)\n c1... | [
"0.60159427",
"0.6003989",
"0.5936057",
"0.5899959",
"0.58792543",
"0.58560514",
"0.5814833",
"0.58042705",
"0.57690716",
"0.5768329",
"0.57617337",
"0.57117414",
"0.5709993",
"0.5708076",
"0.5683127",
"0.56726044",
"0.56690747",
"0.5665278",
"0.5657497",
"0.56303555",
"0.561... | 0.6334938 | 0 |
Given the essential matrix, we derive the camera position and orientation | def ExtractCameraPose(E):
u, s, v = np.linalg.svd(E, full_matrices=True)
w = np.array([[0, -1, 0],
[1, 0, 0],
[0, 0, 1]]).reshape(3, 3)
c1 = u[:, 2].reshape(3, 1)
r1 = np.dot(np.dot(u, w), v).reshape(3, 3)
c2 = -u[:, 2].reshape(3, 1)
r2 = np.dot(np.dot(u, w), v).reshape(3, 3)
c3 = u[:, 2].reshape(3, 1)
r3 = np.dot(np.dot(u, w.T), v).reshape(3, 3)
c4 = -u[:, 2].reshape(3, 1)
r4 = np.dot(np.dot(u, w.T), v).reshape(3, 3)
if np.linalg.det(r1) < 0:
c1 = -c1
r1 = -r1
if np.linalg.det(r2) < 0:
c2 = -c2
r2 = -r2
if np.linalg.det(r3) < 0:
c3 = -c3
r3 = -r3
if np.linalg.det(r4) < 0:
c4 = -c4
r4 = -r4
cam_center = np.array([c1, c2, c3, c4])
cam_rotation = np.array([r1, r2, r3, r4])
return cam_center, cam_rotation | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_camera_orientation(self):\n\n # Create the vector from the camera to the robot\n vector_x = self.robot_x - self.camera_x\n vector_y = self.robot_y - self.camera_y\n vector_z = self.robot_z - self.camera_z\n\n # Calculate yaw and pitch from this vector\n yaw = math.... | [
"0.6524759",
"0.64992476",
"0.6400119",
"0.62868214",
"0.6233258",
"0.62323457",
"0.6178379",
"0.6016908",
"0.6012133",
"0.60015947",
"0.5997646",
"0.59892434",
"0.5961536",
"0.5942139",
"0.59395564",
"0.5925271",
"0.5909638",
"0.58591086",
"0.58126867",
"0.581134",
"0.580240... | 0.7063537 | 0 |
This function returns the extrinsic parameter matrix | def getExtrinsicParameter(K, R, C):
t = np.dot(-R, C)
homogeneous_matrix = np.hstack((R.reshape(3, 3), t))
extrinsic_parameter = np.dot(K, homogeneous_matrix)
return extrinsic_parameter | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_intrinsic_mat(params):\n return np.asarray(\n [\n [params[0], 0.0, params[1]],\n [0.0, params[2], params[3]],\n [0.0, 0.0, 1.0],\n ]\n )",
"def get_extrinsic_matrix(pose):\n batch_size, _ = pose.shape\n rot = pose[:,:3]\n trans = pose[:,3:]\n\... | [
"0.7331173",
"0.63358027",
"0.63124555",
"0.6310796",
"0.61443675",
"0.61443675",
"0.61398846",
"0.6122645",
"0.6090896",
"0.59263265",
"0.58786243",
"0.5862724",
"0.5847503",
"0.58337194",
"0.57778543",
"0.5750955",
"0.57484686",
"0.57484686",
"0.5668891",
"0.5660093",
"0.56... | 0.6725677 | 1 |
Gets the translation vector and rotation matrix of the camera w.r.t the world frame and removes camera frame ambiguity | def getDisambiguousPose(K, C, R, left_features, right_features):
check = 0
for i in range(0, len(R)):
count = 0
extrinsic_params = getExtrinsicParameter(K, R[i], C[i])
for j in range(0, len(left_features)):
X = getTriangulationPoint(K, extrinsic_params, left_features[j], right_features[j])
r3 = R[i][2, :].reshape((1, 3))
cheiralityCondition = np.dot(r3, X[:3] - C[i])
if cheiralityCondition > 0 and X[2] >= 0:
count += 1
if count > check:
check = count
Translation = C[i]
Rotation = R[i]
if Translation[2] < 0:
Translation = -Translation
return Translation, Rotation | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_camera_transform(self):\r\n if not self.pose:\r\n rospy.loginfo(\"no pose!\")\r\n return None\r\n if self.pose.header.frame_id != self.role_name:\r\n rospy.logwarn(\"Unsupported frame received. Supported {}, received {}\".format(\r\n self.role_n... | [
"0.653753",
"0.6497488",
"0.6299928",
"0.62356544",
"0.61046827",
"0.60589045",
"0.60228235",
"0.5942271",
"0.5935986",
"0.5927937",
"0.5889109",
"0.58773947",
"0.58653027",
"0.5864766",
"0.5847944",
"0.58465064",
"0.5835871",
"0.5828304",
"0.57876843",
"0.5779836",
"0.577296... | 0.0 | -1 |
return enantiomer of self, either D or L | def D_or_L(self) -> str:
CO = np.array([self['C'].xyz.x, self['C'].xyz.y, self['C'].xyz.z])
CA = np.array([self['CA'].xyz.x, self['CA'].xyz.y, self['CA'].xyz.z])
CB = np.array([self['CB'].xyz.x, self['CB'].xyz.y, self['CB'].xyz.z])
N = np.array([self['N'].xyz.x, self['N'].xyz.y, self['N'].xyz.z])
v1 = N - CO
v2 = CA - CO
cp = np.cross(v1, v2)
CB_infront = cp.dot(CB-CA) > 0
print(CB_infront)
return 'D' if CB_infront else 'L' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def L(self):\n if not self.isVaild():\n pass\n return self.Lq() + self.r()",
"def exterior_der(self):\n from utilities import format_unop_txt, format_unop_latex\n if self._exterior_derivative is None:\n vmodule = self._vmodule # shortcut\n rname = form... | [
"0.58051234",
"0.5680773",
"0.5520372",
"0.5517061",
"0.5517061",
"0.5517061",
"0.5517061",
"0.54927427",
"0.53145987",
"0.53131396",
"0.53023165",
"0.52391076",
"0.51286054",
"0.5116414",
"0.5094388",
"0.5080737",
"0.50450814",
"0.50200135",
"0.4995237",
"0.4990676",
"0.4958... | 0.5174654 | 12 |
removes all Hydrogen atoms from instance | def remove_hydrogens(self) -> None:
for cid, c in self:
for rid, r in c:
for aid, a in r:
if a.element == 'H':
print('removing H at %s' % aid)
r.remove_atom(a) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete(self):\n del self.shx.atoms[self.index]",
"def strip(self):\n types = [type(self.strip),\n type(self.values),\n type(self.__ne__),\n type(self.__class__)]\n\n for attr in dir(self):\n if not type(getattr(self, attr)) in ty... | [
"0.6937832",
"0.6847128",
"0.6714238",
"0.6525774",
"0.64063466",
"0.63946915",
"0.62644595",
"0.6262052",
"0.6121503",
"0.60625106",
"0.60625106",
"0.6042291",
"0.6015206",
"0.5961813",
"0.5960132",
"0.592724",
"0.5911329",
"0.58740425",
"0.5869668",
"0.5853029",
"0.5847566"... | 0.7476278 | 0 |
collect a set of residues with memb_z within [15, 15] | def memb_residues(pdb: MyPDB) -> list():
result = []
for ch in pdb.chains.values():
for res in ch.values():
if res.memb_z is not None:
result.append(res)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_subset_mz(self, mz):\n regions = self.boxes_mz.at(mz)\n it = BoxHolder()\n for r in regions:\n box = r.data\n it.add_box(box)\n return it",
"def get_subset(mlist,year):\n newlist = []\n for entry in mlist:\n if int(entry[0][:4]) > int(year):\... | [
"0.5860528",
"0.5294917",
"0.5274569",
"0.5238881",
"0.51128125",
"0.50799537",
"0.50743914",
"0.4973342",
"0.49630117",
"0.49471557",
"0.49072868",
"0.48891437",
"0.48831913",
"0.48573068",
"0.48536083",
"0.4842539",
"0.4838259",
"0.48302126",
"0.48269477",
"0.48252738",
"0.... | 0.59874827 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.