add test_R_to_quat

camtools/backend.py

@@ -560,6 +560,22 @@ def create_zeros(
         return torch.zeros(shape, dtype=dtype)
 
 
+def create_empty(
+    shape: Tuple[int, ...],
+    dtype: Any,
+    backend: Literal["numpy", "torch"],
+) -> Tensor:
+    """
+    Call np.empty() or torch.empty() depending on the backend.
+    """
+    if backend == "numpy":
+        return np.empty(shape, dtype=dtype)
+    elif backend == "torch":
+        if not is_torch_available():
+            raise ValueError("Torch is not available.")
+        return torch.empty(shape, dtype=dtype)
+
+
 def get_tensor_backend(arr: Tensor) -> Literal["numpy", "torch"]:
     """
     Get the backend of a tensor.

camtools/convert.py

@@ -13,6 +13,7 @@
     torch,
     create_array,
     create_ones,
+    create_empty,
     get_tensor_backend,
 )
 from jaxtyping import Float

test/test_convert.py

@@ -272,6 +272,58 @@ def test_from_homo():
         ct.convert.from_homo(incorrect_in_val_b)
 
 
+def test_R_to_quat():
+    theta = np.pi / 2  # 90 degree rotation
+
+    # Test for rotation around the x-axis
+    R_x = np.array(
+        [
+            [1, 0, 0],
+            [0, np.cos(theta), -np.sin(theta)],
+            [0, np.sin(theta), np.cos(theta)],
+        ]
+    )
+    gt_quat_x = np.array([np.cos(theta / 2), np.sin(theta / 2), 0, 0])
+    quat_x = ct.convert.R_to_quat(R_x)
+    assert np.allclose(quat_x, gt_quat_x, atol=1e-5)
+
+    # Test for rotation around the y-axis
+    R_y = np.array(
+        [
+            [np.cos(theta), 0, np.sin(theta)],
+            [0, 1, 0],
+            [-np.sin(theta), 0, np.cos(theta)],
+        ]
+    )
+    gt_quat_y = np.array([np.cos(theta / 2), 0, np.sin(theta / 2), 0])
+    quat_y = ct.convert.R_to_quat(R_y)
+    assert np.allclose(quat_y, gt_quat_y, atol=1e-5)
+
+    # Test for rotation around the z-axis
+    R_z = np.array(
+        [
+            [np.cos(theta), -np.sin(theta), 0],
+            [np.sin(theta), np.cos(theta), 0],
+            [0, 0, 1],
+        ]
+    )
+    gt_quat_z = np.array([np.cos(theta / 2), 0, 0, np.sin(theta / 2)])
+    quat_z = ct.convert.R_to_quat(R_z)
+    assert np.allclose(quat_z, gt_quat_z, atol=1e-5)
+
+    # Test with a batch of complex rotations about different axes
+    R_batch = np.array([R_x, R_y, R_z])
+    gt_quat_batch = np.array(
+        [
+            [np.cos(theta / 2), np.sin(theta / 2), 0, 0],
+            [np.cos(theta / 2), 0, np.sin(theta / 2), 0],
+            [np.cos(theta / 2), 0, 0, np.sin(theta / 2)],
+        ]
+    )
+    quat_batch = ct.convert.R_to_quat(R_batch)
+    assert np.allclose(quat_batch, gt_quat_batch, atol=1e-5)
+
+
 def test_R_t_to_cameracenter():
     T = np.array(
         [
@@ -505,53 +557,3 @@ def gen_random_T():
             rtol=1e-5,
             atol=1e-5,
         )
-
-
-# def test_to_homo():
-#     # Regular case
-#     src = np.array(
-#         [
-#             [1, 2],
-#             [3, 4],
-#         ]
-#     )
-#     dst_gt = np.array(
-#         [
-#             [1, 2, 1],
-#             [3, 4, 1],
-#         ]
-#     )
-#     dst = ct.convert.to_homo(src)
-#     np.testing.assert_array_equal(dst, dst_gt)
-
-#     # Exception case
-#     with pytest.raises(ValueError) as _:
-#         src = np.array([1, 2, 3])
-#         ct.convert.to_homo(src)
-
-
-# def test_from_homo():
-#     src = np.array(
-#         [
-#             [2, 4, 2],
-#             [6, 8, 1],
-#         ]
-#     )
-#     dst_gt = np.array(
-#         [
-#             [1, 2],
-#             [6, 8],
-#         ]
-#     )
-#     dst = ct.convert.from_homo(src)
-#     np.testing.assert_array_equal(dst, dst_gt)
-
-#     # Exception case for non-2D input
-#     with pytest.raises(ValueError) as _:
-#         src = np.array([1, 2, 3])
-#         ct.convert.from_homo(src)
-
-#     # Exception case for insufficient columns
-#     with pytest.raises(ValueError) as _:
-#         src = np.array([[1]])
-#         ct.convert.from_homo(src)