update utils3d

utils3d/numpy/__init__.py

@@ -58,6 +58,9 @@ __modules_all__ = {
         'perspective_from_fov_xy',
         'intrinsics_from_focal_center',
         'intrinsics_from_fov',
+        'fov_to_focal',
+        'focal_to_fov',
+        'intrinsics_to_fov',
         'view_look_at',
         'extrinsics_look_at',
         'perspective_to_intrinsics',

utils3d/numpy/transforms.py

@@ -10,6 +10,9 @@ __all__ = [
     'perspective_from_fov_xy',
     'intrinsics_from_focal_center',
     'intrinsics_from_fov',
+    'fov_to_focal',
+    'focal_to_fov',
+    'intrinsics_to_fov',
     'view_look_at',
     'extrinsics_look_at',
     'perspective_to_intrinsics',
@@ -78,12 +81,12 @@ def perspective(
 
 
 def perspective_from_fov(
-        fov: Union[float, np.ndarray],
-        width: Union[int, np.ndarray],
-        height: Union[int, np.ndarray],
-        near: Union[float, np.ndarray],
-        far: Union[float, np.ndarray]
-    ) -> np.ndarray:
+    fov: Union[float, np.ndarray],
+    width: Union[int, np.ndarray],
+    height: Union[int, np.ndarray],
+    near: Union[float, np.ndarray],
+    far: Union[float, np.ndarray]
+) -> np.ndarray:
     """
     Get OpenGL perspective matrix from field of view in largest dimension
 
@@ -193,6 +196,20 @@ def intrinsics_from_fov(
     return ret
 
 
+def focal_to_fov(focal: np.ndarray):
+    return 2 * np.arctan(0.5 / focal)
+
+
+def fov_to_focal(fov: np.ndarray):
+    return 0.5 / np.tan(fov / 2)
+
+
+def intrinsics_to_fov(intrinsics: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+    fov_x = focal_to_fov(intrinsics[..., 0, 0])
+    fov_y = focal_to_fov(intrinsics[..., 1, 1])
+    return fov_x, fov_y
+
+
 @batched(1,1,1)
 def view_look_at(
         eye: np.ndarray,

utils3d/numpy/utils.py

@@ -362,41 +362,46 @@ def image_pixel(
 
 
 def image_mesh(
-    height: int,
-    width: int,
+    *image_attrs: np.ndarray,
     mask: np.ndarray = None,
-    tri: bool = False
-) -> Tuple[np.ndarray, np.ndarray]:
+    tri: bool = False,
+    return_indices: bool = False
+) -> Tuple[np.ndarray, ...]:
     """
-    Get x quad mesh regarding image pixel uv coordinates as vertices and image grid as faces.
+    Get a mesh regarding image pixel uv coordinates as vertices and image grid as faces.
 
     Args:
-        width (int): image width
-        height (int): image height
+        *image_attrs (np.ndarray): image attributes in shape (height, width, [channels])
         mask (np.ndarray, optional): binary mask of shape (height, width), dtype=bool. Defaults to None.
 
     Returns:
-        uv (np.ndarray): uv corresponding to pixels as described in image_uv()
-        faces (np.ndarray): quad faces connecting neighboring pixels
+        faces (np.ndarray): faces connecting neighboring pixels. shape (T, 4) if tri is False, else (T, 3)
+        *vertex_attrs (np.ndarray): vertex attributes in corresponding order with input image_attrs
         indices (np.ndarray, optional): indices of vertices in the original mesh
     """
-    if mask is not None:
-        assert mask.shape[0] == height and mask.shape[1] == width
-        assert mask.dtype == np.bool_
-    uv = image_uv(height, width).reshape((-1, 2))
+    assert (len(image_attrs) > 0) or (mask is not None), "At least one of image_attrs or mask should be provided"
+    height, width = next(image_attrs).shape[:2] if mask is None else mask.shape
+    assert all(img.shape[:2] == (height, width) for img in image_attrs), "All image_attrs should have the same shape"
+    
     row_faces = np.stack([np.arange(0, width - 1, dtype=np.int32), np.arange(width, 2 * width - 1, dtype=np.int32), np.arange(1 + width, 2 * width, dtype=np.int32), np.arange(1, width, dtype=np.int32)], axis=1)
     faces = (np.arange(0, (height - 1) * width, width, dtype=np.int32)[:, None, None] + row_faces[None, :, :]).reshape((-1, 4))
-    if mask is not None:
+    if mask is None:
+        if tri:
+            faces = mesh.triangulate(faces)
+        ret = [faces, *(img.reshape(-1, *img.shape[2:]) for img in image_attrs)]
+        if return_indices:
+            ret.append(np.arange(height * width, dtype=np.int32))
+        return tuple(ret)
+    else:
         quad_mask = (mask[:-1, :-1] & mask[1:, :-1] & mask[1:, 1:] & mask[:-1, 1:]).ravel()
         faces = faces[quad_mask]
-        faces, uv, indices = mesh.remove_unreferenced_vertices(faces, uv, return_indices=True)
         if tri:
             faces = mesh.triangulate(faces)
-        return uv, faces, indices
-    if tri:
-        faces = mesh.triangulate(faces)
-    return uv, faces
-
+        return mesh.remove_unreferenced_vertices(
+            faces, 
+            *(x.reshape(-1, *x.shape[2:]) for x in image_attrs), 
+            return_indices=return_indices
+        )
 
 def image_mesh_from_depth(
     depth: np.ndarray,