def test_gradcheck(self, device):
points1 = torch.rand(1,
8,
2,
device=device,
dtype=torch.float64,
requires_grad=True)
points2 = torch.rand(1, 8, 2, device=device, dtype=torch.float64)
P1 = epi.eye_like(3, points1)
P1 = torch.nn.functional.pad(P1, [0, 1])
P2 = epi.eye_like(3, points2)
P2 = torch.nn.functional.pad(P2, [0, 1])
assert gradcheck(epi.triangulate_points, (P1, P2, points1, points2),
raise_exception=True)
def test_shape(self, batch_size, eye_size, device, dtype):
B, N = batch_size, eye_size
image = torch.rand(B, 3, 4, 4, device=device, dtype=dtype)
identity = epi.eye_like(N, image)
assert identity.shape == (B, N, N)
assert identity.device == image.device
assert identity.dtype == image.dtype
def test_translation(self, device, dtype):
R1 = torch.tensor(
[[[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]],
device=device,
dtype=dtype)
t1 = torch.tensor([[[10.0], [0.0], [0.0]]]).type_as(R1)
R2 = epi.eye_like(3, R1)
t2 = epi.vec_like(3, t1)
R_expected = R1.clone()
t_expected = -t1
R, t = epi.relative_camera_motion(R1, t1, R2, t2)
assert_allclose(R_expected, R)
assert_allclose(t_expected, t)
def get_rotation_matrix2d(center: torch.Tensor, angle: torch.Tensor, scale: torch.Tensor) -> torch.Tensor:
r"""Calculate an affine matrix of 2D rotation.
The function calculates the following matrix:
.. math::
\begin{bmatrix}
\alpha & \beta & (1 - \alpha) \cdot \text{x}
- \beta \cdot \text{y} \\
-\beta & \alpha & \beta \cdot \text{x}
+ (1 - \alpha) \cdot \text{y}
\end{bmatrix}
where
.. math::
\alpha = \text{scale} \cdot cos(\text{angle}) \\
\beta = \text{scale} \cdot sin(\text{angle})
The transformation maps the rotation center to itself
If this is not the target, adjust the shift.
Args:
center: center of the rotation in the source image with shape :math:`(B, 2)`.
angle: rotation angle in degrees. Positive values mean
counter-clockwise rotation (the coordinate origin is assumed to
be the top-left corner) with shape :math:`(B)`.
scale: scale factor for x, y scaling with shape :math:`(B, 2)`.
Returns:
the affine matrix of 2D rotation with shape :math:`(B, 2, 3)`.
Example:
>>> center = torch.zeros(1, 2)
>>> scale = torch.ones((1, 2))
>>> angle = 45. * torch.ones(1)
>>> get_rotation_matrix2d(center, angle, scale)
tensor([[[ 0.7071, 0.7071, 0.0000],
[-0.7071, 0.7071, 0.0000]]])
.. note::
This function is often used in conjunction with :func:`warp_affine`.
"""
if not isinstance(center, torch.Tensor):
raise TypeError(f"Input center type is not a torch.Tensor. Got {type(center)}")
if not isinstance(angle, torch.Tensor):
raise TypeError(f"Input angle type is not a torch.Tensor. Got {type(angle)}")
if not isinstance(scale, torch.Tensor):
raise TypeError(f"Input scale type is not a torch.Tensor. Got {type(scale)}")
if not (len(center.shape) == 2 and center.shape[1] == 2):
raise ValueError(f"Input center must be a Bx2 tensor. Got {center.shape}")
if not len(angle.shape) == 1:
raise ValueError(f"Input angle must be a B tensor. Got {angle.shape}")
if not (len(scale.shape) == 2 and scale.shape[1] == 2):
raise ValueError(f"Input scale must be a Bx2 tensor. Got {scale.shape}")
if not (center.shape[0] == angle.shape[0] == scale.shape[0]):
raise ValueError(
"Inputs must have same batch size dimension. Got center {}, angle {} and scale {}".format(
center.shape, angle.shape, scale.shape
)
)
if not (center.device == angle.device == scale.device) or not (center.dtype == angle.dtype == scale.dtype):
raise ValueError(
"Inputs must have same device Got center ({}, {}), angle ({}, {}) and scale ({}, {})".format(
center.device, center.dtype, angle.device, angle.dtype, scale.device, scale.dtype
)
)
shift_m = eye_like(3, center)
shift_m[:, :2, 2] = center
shift_m_inv = eye_like(3, center)
shift_m_inv[:, :2, 2] = -center
scale_m = eye_like(3, center)
scale_m[:, 0, 0] *= scale[:, 0]
scale_m[:, 1, 1] *= scale[:, 1]
rotat_m = eye_like(3, center)
rotat_m[:, :2, :2] = angle_to_rotation_matrix(angle)
affine_m = shift_m @ rotat_m @ scale_m @ shift_m_inv
return affine_m[:, :2, :] # Bx2x3
def test_smoke(self, device, dtype):
image = torch.rand(1, 3, 4, 4, device=device, dtype=dtype)
identity = epi.eye_like(3, image)
assert identity.shape == (1, 3, 3)
assert identity.device == image.device
assert identity.dtype == image.dtype