Download python/isaacgym/torch_utils.py from e-zorzi/data_for_skillblender: direct link, hf CLI and curl.
- Browser
- Download file 6.01 kB
-
https://huggingface.co/datasets/e-zorzi/data_for_skillblender/resolve/main/python/isaacgym/torch_utils.py
- Command line
-
hf download hf://datasets/e-zorzi/data_for_skillblender/python/isaacgym/torch_utils.py
-
curl -L -o torch_utils.py https://huggingface.co/datasets/e-zorzi/data_for_skillblender/resolve/main/python/isaacgym/torch_utils.py
6.01 kB
| """ | |
| Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. | |
| NVIDIA CORPORATION and its licensors retain all intellectual property | |
| and proprietary rights in and to this software, related documentation | |
| and any modifications thereto. Any use, reproduction, disclosure or | |
| distribution of this software and related documentation without an express | |
| license agreement from NVIDIA CORPORATION is strictly prohibited. | |
| """ | |
| import torch | |
| import numpy as np | |
| def to_torch(x, dtype=torch.float, device='cuda:0', requires_grad=False): | |
| return torch.tensor(x, dtype=dtype, device=device, requires_grad=requires_grad) | |
| def quat_mul(a, b): | |
| assert a.shape == b.shape | |
| shape = a.shape | |
| a = a.reshape(-1, 4) | |
| b = b.reshape(-1, 4) | |
| x1, y1, z1, w1 = a[:, 0], a[:, 1], a[:, 2], a[:, 3] | |
| x2, y2, z2, w2 = b[:, 0], b[:, 1], b[:, 2], b[:, 3] | |
| ww = (z1 + x1) * (x2 + y2) | |
| yy = (w1 - y1) * (w2 + z2) | |
| zz = (w1 + y1) * (w2 - z2) | |
| xx = ww + yy + zz | |
| qq = 0.5 * (xx + (z1 - x1) * (x2 - y2)) | |
| w = qq - ww + (z1 - y1) * (y2 - z2) | |
| x = qq - xx + (x1 + w1) * (x2 + w2) | |
| y = qq - yy + (w1 - x1) * (y2 + z2) | |
| z = qq - zz + (z1 + y1) * (w2 - x2) | |
| quat = torch.stack([x, y, z, w], dim=-1).view(shape) | |
| return quat | |
| def normalize(x, eps: float = 1e-9): | |
| return x / x.norm(p=2, dim=-1).clamp(min=eps, max=None).unsqueeze(-1) | |
| def quat_apply(a, b): | |
| shape = b.shape | |
| a = a.reshape(-1, 4) | |
| b = b.reshape(-1, 3) | |
| xyz = a[:, :3] | |
| t = xyz.cross(b, dim=-1) * 2 | |
| return (b + a[:, 3:] * t + xyz.cross(t, dim=-1)).view(shape) | |
| def quat_rotate(q, v): | |
| shape = q.shape | |
| q_w = q[:, -1] | |
| q_vec = q[:, :3] | |
| a = v * (2.0 * q_w ** 2 - 1.0).unsqueeze(-1) | |
| b = torch.cross(q_vec, v, dim=-1) * q_w.unsqueeze(-1) * 2.0 | |
| c = q_vec * \ | |
| torch.bmm(q_vec.view(shape[0], 1, 3), v.view( | |
| shape[0], 3, 1)).squeeze(-1) * 2.0 | |
| return a + b + c | |
| def quat_rotate_inverse(q, v): | |
| shape = q.shape | |
| q_w = q[:, -1] | |
| q_vec = q[:, :3] | |
| a = v * (2.0 * q_w ** 2 - 1.0).unsqueeze(-1) | |
| b = torch.cross(q_vec, v, dim=-1) * q_w.unsqueeze(-1) * 2.0 | |
| c = q_vec * \ | |
| torch.bmm(q_vec.view(shape[0], 1, 3), v.view( | |
| shape[0], 3, 1)).squeeze(-1) * 2.0 | |
| return a - b + c | |
| def quat_conjugate(a): | |
| shape = a.shape | |
| a = a.reshape(-1, 4) | |
| return torch.cat((-a[:, :3], a[:, -1:]), dim=-1).view(shape) | |
| def quat_unit(a): | |
| return normalize(a) | |
| def quat_from_angle_axis(angle, axis): | |
| theta = (angle / 2).unsqueeze(-1) | |
| xyz = normalize(axis) * theta.sin() | |
| w = theta.cos() | |
| return quat_unit(torch.cat([xyz, w], dim=-1)) | |
| def normalize_angle(x): | |
| return torch.atan2(torch.sin(x), torch.cos(x)) | |
| def tf_inverse(q, t): | |
| q_inv = quat_conjugate(q) | |
| return q_inv, -quat_apply(q_inv, t) | |
| def tf_apply(q, t, v): | |
| return quat_apply(q, v) + t | |
| def tf_vector(q, v): | |
| return quat_apply(q, v) | |
| def tf_combine(q1, t1, q2, t2): | |
| return quat_mul(q1, q2), quat_apply(q1, t2) + t1 | |
| def get_basis_vector(q, v): | |
| return quat_rotate(q, v) | |
| def get_axis_params(value, axis_idx, x_value=0., dtype=np.float, n_dims=3): | |
| """construct arguments to `Vec` according to axis index. | |
| """ | |
| zs = np.zeros((n_dims,)) | |
| assert axis_idx < n_dims, "the axis dim should be within the vector dimensions" | |
| zs[axis_idx] = 1. | |
| params = np.where(zs == 1., value, zs) | |
| params[0] = x_value | |
| return list(params.astype(dtype)) | |
| def copysign(a, b): | |
| # type: (float, Tensor) -> Tensor | |
| a = torch.tensor(a, device=b.device, dtype=torch.float).repeat(b.shape[0]) | |
| return torch.abs(a) * torch.sign(b) | |
| def get_euler_xyz(q): | |
| qx, qy, qz, qw = 0, 1, 2, 3 | |
| # roll (x-axis rotation) | |
| sinr_cosp = 2.0 * (q[:, qw] * q[:, qx] + q[:, qy] * q[:, qz]) | |
| cosr_cosp = q[:, qw] * q[:, qw] - q[:, qx] * \ | |
| q[:, qx] - q[:, qy] * q[:, qy] + q[:, qz] * q[:, qz] | |
| roll = torch.atan2(sinr_cosp, cosr_cosp) | |
| # pitch (y-axis rotation) | |
| sinp = 2.0 * (q[:, qw] * q[:, qy] - q[:, qz] * q[:, qx]) | |
| pitch = torch.where(torch.abs(sinp) >= 1, copysign( | |
| np.pi / 2.0, sinp), torch.asin(sinp)) | |
| # yaw (z-axis rotation) | |
| siny_cosp = 2.0 * (q[:, qw] * q[:, qz] + q[:, qx] * q[:, qy]) | |
| cosy_cosp = q[:, qw] * q[:, qw] + q[:, qx] * \ | |
| q[:, qx] - q[:, qy] * q[:, qy] - q[:, qz] * q[:, qz] | |
| yaw = torch.atan2(siny_cosp, cosy_cosp) | |
| return roll % (2*np.pi), pitch % (2*np.pi), yaw % (2*np.pi) | |
| def quat_from_euler_xyz(roll, pitch, yaw): | |
| cy = torch.cos(yaw * 0.5) | |
| sy = torch.sin(yaw * 0.5) | |
| cr = torch.cos(roll * 0.5) | |
| sr = torch.sin(roll * 0.5) | |
| cp = torch.cos(pitch * 0.5) | |
| sp = torch.sin(pitch * 0.5) | |
| qw = cy * cr * cp + sy * sr * sp | |
| qx = cy * sr * cp - sy * cr * sp | |
| qy = cy * cr * sp + sy * sr * cp | |
| qz = sy * cr * cp - cy * sr * sp | |
| return torch.stack([qx, qy, qz, qw], dim=-1) | |
| def torch_rand_float(lower, upper, shape, device): | |
| # type: (float, float, Tuple[int, int], str) -> Tensor | |
| return (upper - lower) * torch.rand(*shape, device=device) + lower | |
| def torch_random_dir_2(shape, device): | |
| # type: (Tuple[int, int], str) -> Tensor | |
| angle = torch_rand_float(-np.pi, np.pi, shape, device).squeeze(-1) | |
| return torch.stack([torch.cos(angle), torch.sin(angle)], dim=-1) | |
| def tensor_clamp(t, min_t, max_t): | |
| return torch.max(torch.min(t, max_t), min_t) | |
| def scale(x, lower, upper): | |
| return (0.5 * (x + 1.0) * (upper - lower) + lower) | |
| def unscale(x, lower, upper): | |
| return (2.0 * x - upper - lower) / (upper - lower) | |
| def unscale_np(x, lower, upper): | |
| return (2.0 * x - upper - lower) / (upper - lower) | |