Upload 104 files

utils3d/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

utils3d/.gitignore

@@ -0,0 +1,118 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+.vscode
+test/results_to_check
+timetest.py

utils3d/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 EasternJournalist
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

utils3d/README.md

@@ -0,0 +1,46 @@
+# utils3d
+Easy 3D python utilities for computer vision and graphics researchers.
+
+Supports:
+* Transformation between OpenCV and OpenGL coordinate systems, **no more confusion**
+* Easy rasterization, **no worries about OpenGL objects and buffers**
+* Some mesh processing utilities, **all vectorized for effciency; some differentiable**
+* Projection, unprojection, depth-based image warping, flow-based image warping...
+* Easy Reading and writing .obj, .ply files
+* Reading and writing Colmap format camera parameters
+* NeRF/MipNeRF utilities
+
+For most functions, there are both numpy (indifferentiable) and pytorch implementations (differentiable).
+
+Pytorch is not required for using this package, but if you want to use the differentiable functions, you will need to install pytorch (and nvdiffrast if you want to use the pytorch rasterization functions).
+
+## Install
+
+Install by git
+
+```bash
+pip install git+https://github.com/EasternJournalist/utils3d.git#egg=utils3d
+```
+
+or clone the repo and install with `-e` option for convenient updating and modifying.
+
+```bash
+git clone https://github.com/EasternJournalist/utils3d.git
+pip install -e ./utils3d
+```
+
+## Topics (TODO)
+
+### Camera
+
+### Rotations
+
+### Mesh
+
+### Rendering
+
+### Projection
+
+### Image warping
+
+### NeRF

utils3d/gen_unified_interface.py

@@ -0,0 +1,106 @@
+import inspect
+import textwrap
+import re
+import itertools
+import numbers
+import importlib
+import sys
+import functools
+from pathlib import Path
+
+from utils3d._helpers import suppress_traceback
+
+
+def _contains_tensor(obj):
+    if isinstance(obj, (list, tuple)):
+        return any(_contains_tensor(item) for item in obj)
+    elif isinstance(obj, dict):
+        return any(_contains_tensor(value) for value in obj.values())
+    else:
+        import torch
+        return isinstance(obj, torch.Tensor)
+
+@suppress_traceback
+def _call_based_on_args(fname, args, kwargs):
+    if 'torch' in sys.modules:
+        if any(_contains_tensor(arg) for arg in args) or any(_contains_tensor(v) for v in kwargs.values()):
+            fn = getattr(utils3d.torch, fname, None)
+            if fn is None:
+                raise NotImplementedError(f"Function {fname} has no torch implementation.")
+            return fn(*args, **kwargs)
+    fn = getattr(utils3d.numpy, fname, None)
+    if fn is None:
+        raise NotImplementedError(f"Function {fname} has no numpy implementation.") 
+    return fn(*args, **kwargs)
+    
+
+def extract_signature(fn):
+    signature = inspect.signature(fn)
+    
+    signature_str = str(signature)
+
+    signature_str = re.sub(r"<class '.*'>", lambda m: m.group(0).split('\'')[1], signature_str)
+    signature_str = re.sub(r"(?<!\.)numpy\.", "numpy_.", signature_str)
+    signature_str = re.sub(r"(?<!\.)torch\.", "torch_.", signature_str)
+    
+    return signature_str
+
+
+
+if __name__ == "__main__":
+    import utils3d.numpy, utils3d.torch
+    numpy_impl = utils3d.numpy
+    torch_impl = utils3d.torch
+    numpy_funcs = {name: getattr(numpy_impl, name) for name in numpy_impl.__all__}
+    torch_funcs = {name: getattr(torch_impl, name) for name in torch_impl.__all__}
+
+    all = {**numpy_funcs, **torch_funcs}
+
+    Path("utils3d/_unified").mkdir(exist_ok=True)
+
+    with open("utils3d/_unified/__init__.pyi", "w", encoding="utf-8") as f:
+        f.write(inspect.cleandoc(
+            f"""
+            # Auto-generated interface file
+            from typing import List, Tuple, Dict, Union, Optional, Any, overload, Literal, Callable
+            import numpy as numpy_
+            import torch as torch_
+            import nvdiffrast.torch
+            import numbers
+            from . import numpy, torch
+            import utils3d.numpy, utils3d.torch
+            """
+        ))
+        f.write("\n\n")
+        f.write(f"__all__ = [{', \n'.join('\"' + s + '\"' for s in all.keys())}]\n\n")
+
+        for fname, fn in itertools.chain(numpy_funcs.items(), torch_funcs.items()):
+            sig, doc = extract_signature(fn), inspect.getdoc(fn)
+
+            f.write(f"@overload\n")
+            f.write(f"def {fname}{sig}:\n")
+            f.write(f"    \"\"\"{doc}\"\"\"\n" if doc else "")
+            f.write(f"    {fn.__module__}.{fn.__qualname__}\n\n")
+
+    with open("utils3d/_unified/__init__.py", "w", encoding="utf-8") as f:
+        f.write(inspect.cleandoc(
+            f"""
+            # Auto-generated implementation redirecting to numpy/torch implementations
+            import sys
+            from typing import TYPE_CHECKING
+            import utils3d
+            from .._helpers import suppress_traceback
+            """
+        ))
+        f.write("\n\n")
+        f.write(f"__all__ = [{', \n'.join('\"' + s + '\"' for s in all.keys())}]\n\n")
+        f.write(inspect.getsource(_contains_tensor) + "\n\n")
+        f.write(inspect.getsource(_call_based_on_args) + "\n\n")
+
+        for fname in {**numpy_funcs, **torch_funcs}:
+            f.write(f'@suppress_traceback\n')
+            f.write(f"def {fname}(*args, **kwargs):\n")
+            f.write(f"    if TYPE_CHECKING:  # redirected to:\n")
+            f.write(f"        {'utils3d.numpy.' + fname if fname in numpy_funcs else 'None'}, {'utils3d.torch.'+ fname if fname in torch_funcs else 'None'}\n")
+            f.write(f"    return _call_based_on_args('{fname}', args, kwargs)\n\n")
+            

utils3d/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "utils3d"
+version = "0.0.2"
+description = "A small package for 3D graphics"
+readme = "README.md"
+authors = [
+    {name = "EasternJournalist", email = "wangrc2081cs@mail.ustc.edu.cn"}
+]
+license = {text = "MIT"}
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent"
+]
+dependencies = [
+    "moderngl",
+    "numpy",
+    "plyfile",
+    "scipy"
+]
+requires-python = ">=3.7"
+
+[project.urls]
+Homepage = "https://github.com/EasternJournalist/utils3d"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["utils3d*"]
+
+[tool.setuptools.package-data]
+"utils3d.numpy.shaders" = ["*"]

utils3d/test/io_/write_ply.py

@@ -0,0 +1,22 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..')))
+import utils3d
+import numpy as np
+
+def run():
+    image_uv, image_mesh = utils3d.numpy.utils.image_mesh(128, 128)
+    image_mesh = image_mesh.reshape(-1, 4)
+    depth = np.ones((128, 128), dtype=float) * 2
+    depth[32:96, 32:96] = 1
+    depth = depth.reshape(-1)
+    intrinsics = utils3d.numpy.transforms.intrinsics_from_fov(1.0, 128, 128)
+    intrinsics = utils3d.numpy.transforms.normalize_intrinsics(intrinsics, 128, 128)
+    extrinsics = utils3d.numpy.transforms.extrinsics_look_at([0, 0, 1], [0, 0, 0], [0, 1, 0])
+    pts = utils3d.numpy.transforms.unproject_cv(image_uv, depth, extrinsics, intrinsics)
+    pts = pts.reshape(-1, 3)
+    image_mesh = utils3d.numpy.mesh.triangulate(image_mesh, vertices=pts)
+    utils3d.io.write_ply(os.path.join(os.path.dirname(__file__), '..', 'results_to_check', 'write_ply.ply'), pts, image_mesh)
+
+if __name__ == '__main__':
+    run()

utils3d/test/numpy_/mesh/compute_face_angle.py

@@ -0,0 +1,46 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+            vertices = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0]], dtype=float)
+            faces = np.array([[0, 1, 2]])
+            expected = np.array([[np.pi/2, np.pi/4, np.pi/4]])
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+            N = np.random.randint(100, 1000)
+            vertices = np.random.rand(*spatial, N, 3)
+            L = np.random.randint(1, 1000)
+            faces = np.random.randint(0, N, size=(*spatial, L, 3))
+            faces[..., 1] = (faces[..., 0] + 1) % N
+            faces[..., 2] = (faces[..., 0] + 2) % N
+
+            faces_ = faces.reshape(-1, L, 3)
+            vertices_ = vertices.reshape(-1, N, 3)
+            N = vertices_.shape[0]
+            expected = np.zeros((N, L, 3), dtype=float)
+            for i in range(3):
+                edge0 = vertices_[np.arange(N)[:, None], faces_[..., (i+1)%3]] - vertices_[np.arange(N)[:, None], faces_[..., i]]
+                edge1 = vertices_[np.arange(N)[:, None], faces_[..., (i+2)%3]] - vertices_[np.arange(N)[:, None], faces_[..., i]]
+                expected[..., i] = np.arccos(np.sum(
+                    edge0 / np.linalg.norm(edge0, axis=-1, keepdims=True) * \
+                    edge1 / np.linalg.norm(edge1, axis=-1, keepdims=True),
+                    axis=-1
+                ))
+            expected = expected.reshape(*spatial, L, 3)
+
+        actual = utils3d.numpy.compute_face_angle(vertices, faces)
+        
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'{faces}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/numpy_/mesh/compute_face_normal.py

@@ -0,0 +1,41 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+            vertices = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0]], dtype=float)
+            faces = np.array([[0, 1, 2]])
+            expected = np.array([[0, 0, 1]])
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+            N = np.random.randint(100, 1000)
+            vertices = np.random.rand(*spatial, N, 3)
+            L = np.random.randint(1, 1000)
+            faces = np.random.randint(0, N, size=(*spatial, L, 3))
+            faces[..., 1] = (faces[..., 0] + 1) % N
+            faces[..., 2] = (faces[..., 0] + 2) % N
+
+            faces_ = faces.reshape(-1, L, 3)
+            vertices_ = vertices.reshape(-1, N, 3)
+            N = vertices_.shape[0]
+            expected = np.cross(
+                vertices_[np.arange(N)[:, None], faces_[..., 1]] - vertices_[np.arange(N)[:, None], faces_[..., 0]],
+                vertices_[np.arange(N)[:, None], faces_[..., 2]] - vertices_[np.arange(N)[:, None], faces_[..., 0]]
+            ).reshape(*spatial, L, 3)
+            expected = np.nan_to_num(expected / np.linalg.norm(expected, axis=-1, keepdims=True))
+
+        actual = utils3d.numpy.compute_face_normal(vertices, faces)
+        
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'{faces}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/numpy_/mesh/compute_vertex_normal.py

@@ -0,0 +1,43 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+from trimesh import geometry
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+            vertices = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0]], dtype=float)
+            faces = np.array([[0, 1, 2]])
+            expected = np.array([[0, 0, 1], [0, 0, 1], [0, 0, 1]])
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+            N = np.random.randint(100, 1000)
+            vertices = np.random.rand(*spatial, N, 3)
+            L = np.random.randint(1, 1000)
+            faces = np.random.randint(0, N, size=(*spatial, L, 3))
+            faces[..., 1] = (faces[..., 0] + 1) % N
+            faces[..., 2] = (faces[..., 0] + 2) % N
+            face_normals = utils3d.numpy.compute_face_normal(vertices, faces)
+
+            faces_ = faces.reshape(-1, L, 3)
+            face_normals = face_normals.reshape(-1, L, 3)
+            vertices_normals = []
+            for face, face_normal in zip(faces_, face_normals):
+                vertices_normals.append(
+                    geometry.mean_vertex_normals(N, face, face_normal)
+                )
+            expected = np.array(vertices_normals).reshape(*spatial, N, 3)
+
+        actual = utils3d.numpy.compute_vertex_normal(vertices, faces)
+        
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'{faces}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/numpy_/mesh/compute_vertex_normal_weighted.py

@@ -0,0 +1,45 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+from trimesh import geometry
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+            vertices = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0]], dtype=float)
+            faces = np.array([[0, 1, 2]])
+            expected = np.array([[0, 0, 1], [0, 0, 1], [0, 0, 1]])
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+            N = np.random.randint(100, 1000)
+            vertices = np.random.rand(*spatial, N, 3)
+            L = np.random.randint(1, 1000)
+            faces = np.random.randint(0, N, size=(*spatial, L, 3))
+            faces[..., 1] = (faces[..., 0] + 1) % N
+            faces[..., 2] = (faces[..., 0] + 2) % N
+            face_normals = utils3d.numpy.compute_face_normal(vertices, faces)
+            face_angles = utils3d.numpy.compute_face_angle(vertices, faces)
+            
+            faces_ = faces.reshape(-1, L, 3)
+            face_normals = face_normals.reshape(-1, L, 3)
+            face_angles = face_angles.reshape(-1, L, 3)
+            vertices_normals = []
+            for face, face_normal, face_angle in zip(faces_, face_normals, face_angles):
+                vertices_normals.append(
+                    geometry.weighted_vertex_normals(N, face, face_normal, face_angle)
+                )
+            expected = np.array(vertices_normals).reshape(*spatial, N, 3)
+
+        actual = utils3d.numpy.compute_vertex_normal_weighted(vertices, faces)
+        
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'{faces}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/numpy_/mesh/merge_duplicate_vertices.py

@@ -0,0 +1,39 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+            vertices = np.array([[0, 0, 0], [1, 0, 0], [1, 0, 0]], dtype=float)
+            faces = np.array([[0, 1, 2]])
+            expected_vertices = np.array([[0, 0, 0], [1, 0, 0]])
+            expected_faces = np.array([[0, 1, 1]])
+            expected = expected_vertices[expected_faces]
+        else:
+            N = np.random.randint(100, 1000)
+            vertices = np.random.rand(N, 3)
+            L = np.random.randint(1, 1000)
+            faces = np.random.randint(0, N, size=(L, 3))
+            faces[..., 1] = (faces[..., 0] + 1) % N
+            faces[..., 2] = (faces[..., 0] + 2) % N
+            vertices[-(N//2):] = vertices[:N//2]
+            
+            expected_vertices = vertices[:-(N//2)].copy()
+            expected_faces = faces.copy()
+            expected_faces[expected_faces >= N - N//2] -= N - N//2
+            expected = expected_vertices[expected_faces]
+
+        actual_vertices, actual_faces = utils3d.numpy.merge_duplicate_vertices(vertices, faces)
+        actual = actual_vertices[actual_faces]
+                    
+        assert expected_vertices.shape == actual_vertices.shape and np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'{faces}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/numpy_/mesh/remove_corrupted_faces.py

@@ -0,0 +1,30 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+
+def run():
+    for i in range(100):
+        if i == 0:
+            faces = np.array([[0, 1, 2], [0, 2, 2], [0, 2, 3]])
+            expected = np.array([[0, 1, 2], [0, 2, 3]])
+        else:
+            L = np.random.randint(1, 1000)
+            N = np.random.randint(100, 1000)
+            faces = np.random.randint(0, N, size=(L, 3))
+            faces[..., 1] = (faces[..., 0] + 1) % N
+            faces[..., 2] = (faces[..., 0] + 2) % N
+            corrupted = np.random.randint(0, 2, size=L).astype(bool)
+            faces[corrupted, 1] = faces[corrupted, 0]
+            expected = faces[~corrupted]
+
+        actual = utils3d.numpy.remove_corrupted_faces(faces)
+        
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'{faces}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/numpy_/mesh/triangulate.py

@@ -0,0 +1,33 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+            L = 1
+            N = 5
+            faces = np.array([[0, 1, 2, 3, 4]])
+            expected = np.array([[0, 1, 2], [0, 2, 3], [0, 3, 4]])
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+            L = np.random.randint(1, 1000)
+            N = np.random.randint(3, 10)
+            faces = np.random.randint(0, 10000, size=(*spatial, L, N))
+
+            loop_indices = [[0, i, i + 1] for i in range(1, N - 1)]
+            expected = faces[..., loop_indices].reshape((*spatial, L * (N - 2), 3))
+
+        actual = utils3d.numpy.triangulate(faces)
+        
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'{faces}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/numpy_/rasterization/warp_image_by_depth.py

@@ -0,0 +1,30 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import imageio
+
+def run():
+    depth = np.ones((128, 128), dtype=np.float32) * 2
+    depth[32:48, 32:48] = 1
+    intrinsics = utils3d.numpy.transforms.intrinsics(1.0, 1.0, 0.5, 0.5).astype(np.float32)
+    extrinsics_src = utils3d.numpy.transforms.extrinsics_look_at([0, 0, 1], [0, 0, 0], [0, 1, 0]).astype(np.float32)
+    extrinsics_tgt = utils3d.numpy.transforms.extrinsics_look_at([1, 0, 1], [0, 0, 0], [0, 1, 0]).astype(np.float32)
+    ctx = utils3d.numpy.rasterization.RastContext(
+        standalone=True,
+        backend='egl',
+        device_index=0,
+    )
+    uv, _ = utils3d.numpy.rasterization.warp_image_by_depth(
+        ctx,
+        depth,
+        extrinsics_src=extrinsics_src,
+        extrinsics_tgt=extrinsics_tgt,
+        intrinsics_src=intrinsics
+    )
+    uv = (np.concatenate([uv, np.zeros((128, 128, 1), dtype=np.float32)], axis=-1) * 255).astype(np.uint8)
+    imageio.imwrite(os.path.join(os.path.dirname(__file__), '..', '..', 'results_to_check', 'warp_image_uv.png'), uv)
+
+if __name__ == '__main__':
+    run()

utils3d/test/numpy_/transforms/crop_intrinsic.py

@@ -0,0 +1,53 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+        fov = np.random.uniform(5 / 180 * np.pi, 175 / 180 * np.pi, spatial)
+        width = np.random.uniform(1, 10000, spatial)
+        height = np.random.uniform(1, 10000, spatial)
+        left = np.random.uniform(0, width, spatial)
+        top = np.random.uniform(0, height, spatial)
+        crop_width = np.random.uniform(0, width - left, spatial)
+        crop_height = np.random.uniform(0, height - top, spatial)
+
+        focal = np.maximum(width, height) / (2 * np.tan(fov / 2))
+        cx = width / 2 - left
+        cy = height / 2 - top
+        expected = np.zeros((*spatial, 3, 3))
+        expected[..., 0, 0] = focal
+        expected[..., 1, 1] = focal
+        expected[..., 0, 2] = cx
+        expected[..., 1, 2] = cy
+        expected[..., 2, 2] = 1
+        expected = utils3d.numpy.normalize_intrinsics(expected, crop_width, crop_height)
+
+        actual = utils3d.numpy.crop_intrinsics(
+            utils3d.numpy.normalize_intrinsics(
+                utils3d.numpy.intrinsics_from_fov(fov, width, height),
+                width, height
+            ),
+            width, height, left, top, crop_width, crop_height
+        )
+
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'\tfov: {fov}\n' + \
+            f'\twidth: {width}\n' + \
+            f'\theight: {height}\n' + \
+            f'\tleft: {left}\n' + \
+            f'\ttop: {top}\n' + \
+            f'\tcrop_width: {crop_width}\n' + \
+            f'\tcrop_height: {crop_height}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/numpy_/transforms/extrinsic_look_at.py

@@ -0,0 +1,39 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import glm
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+        eye = np.random.uniform(-10, 10, [*spatial, 3]).astype(np.float32)
+        lookat = np.random.uniform(-10, 10, [*spatial, 3]).astype(np.float32)
+        up = np.random.uniform(-10, 10, [*spatial, 3]).astype(np.float32)
+
+        expected = []
+        for i in range(np.prod(spatial) if len(spatial) > 0 else 1):
+            expected.append(utils3d.numpy.view_to_extrinsics(np.array(glm.lookAt(
+                glm.vec3(eye.reshape([-1, 3])[i]),
+                glm.vec3(lookat.reshape([-1, 3])[i]),
+                glm.vec3(up.reshape([-1, 3])[i])
+            ))))
+        expected = np.concatenate(expected, axis=0).reshape([*spatial, 4, 4])
+
+        actual = utils3d.numpy.extrinsics_look_at(eye, lookat, up)
+        
+        assert np.allclose(expected, actual, 1e-5, 1e-5), '\n' + \
+            'Input:\n' + \
+            f'eye: {eye}\n' + \
+            f'lookat: {lookat}\n' + \
+            f'up: {up}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'
+        

utils3d/test/numpy_/transforms/extrinsic_to_view.py

@@ -0,0 +1,32 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import glm
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+        eye = np.random.uniform(-10, 10, [*spatial, 3]).astype(np.float32)
+        lookat = np.random.uniform(-10, 10, [*spatial, 3]).astype(np.float32)
+        up = np.random.uniform(-10, 10, [*spatial, 3]).astype(np.float32)
+
+        expected = utils3d.numpy.view_look_at(eye, lookat, up)
+
+        actual = utils3d.numpy.view_to_extrinsics(utils3d.numpy.extrinsics_look_at(eye, lookat, up))
+        
+        assert np.allclose(expected, actual, 1e-5, 1e-5), '\n' + \
+            'Input:\n' + \
+            f'eye: {eye}\n' + \
+            f'lookat: {lookat}\n' + \
+            f'up: {up}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'
+        

utils3d/test/numpy_/transforms/intrinsic.py

@@ -0,0 +1,37 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+        focal_x = np.random.uniform(1, 10000, spatial)
+        focal_y = np.random.uniform(1, 10000, spatial)
+        center_x = np.random.uniform(1, 10000, spatial)
+        center_y = np.random.uniform(1, 10000, spatial)
+
+        expected = np.zeros((*spatial, 3, 3))
+        expected[..., 0, 0] = focal_x
+        expected[..., 1, 1] = focal_y
+        expected[..., 0, 2] = center_x
+        expected[..., 1, 2] = center_y
+        expected[..., 2, 2] = 1
+  
+        actual = utils3d.numpy.intrinsics(focal_x, focal_y, center_x, center_y)
+        
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'\tfocal_x: {focal_x}\n' + \
+            f'\tfocal_y: {focal_y}\n' + \
+            f'\tcenter_x: {center_x}\n' + \
+            f'\tcenter_y: {center_y}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/numpy_/transforms/intrinsic_from_fov.py

@@ -0,0 +1,38 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+        fov = np.random.uniform(5 / 180 * np.pi, 175 / 180 * np.pi, spatial)
+        width = np.random.uniform(1, 10000, spatial)
+        height = np.random.uniform(1, 10000, spatial)
+
+        focal = np.maximum(width, height) / (2 * np.tan(fov / 2))
+        cx = width / 2
+        cy = height / 2
+        expected = np.zeros((*spatial, 3, 3))
+        expected[..., 0, 0] = focal
+        expected[..., 1, 1] = focal
+        expected[..., 0, 2] = cx
+        expected[..., 1, 2] = cy
+        expected[..., 2, 2] = 1
+
+        actual = utils3d.numpy.intrinsics_from_fov(fov, width, height)
+
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'\tfov: {fov}\n' + \
+            f'\twidth: {width}\n' + \
+            f'\theight: {height}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/numpy_/transforms/intrinsic_from_fov_xy.py

@@ -0,0 +1,36 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+        fov_x = np.random.uniform(5 / 180 * np.pi, 175 / 180 * np.pi, spatial)
+        fov_y = np.random.uniform(5 / 180 * np.pi, 175 / 180 * np.pi, spatial)
+
+        focal_x = 0.5 / np.tan(fov_x / 2)
+        focal_y = 0.5 / np.tan(fov_y / 2)
+        cx = cy = 0.5
+        expected = np.zeros((*spatial, 3, 3))
+        expected[..., 0, 0] = focal_x
+        expected[..., 1, 1] = focal_y
+        expected[..., 0, 2] = cx
+        expected[..., 1, 2] = cy
+        expected[..., 2, 2] = 1
+
+        actual = utils3d.numpy.intrinsics_from_fov_xy(fov_x, fov_y)
+
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'\tfov_x: {fov_x}\n' + \
+            f'\tfov_y: {fov_y}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/numpy_/transforms/intrinsic_to_perspective.py

@@ -0,0 +1,38 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import glm
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+        fov_x = np.random.uniform(5 / 180 * np.pi, 175 / 180 * np.pi, spatial)
+        fov_y = np.random.uniform(5 / 180 * np.pi, 175 / 180 * np.pi, spatial)
+        near = np.random.uniform(0.1, 100, spatial)
+        far = np.random.uniform(near*2, 1000, spatial)
+
+        expected = utils3d.numpy.perspective_from_fov_xy(fov_x, fov_y, near, far)
+
+        actual = utils3d.numpy.intrinsics_to_perspective(
+            utils3d.numpy.intrinsics_from_fov_xy(fov_x, fov_y),
+            near,
+            far
+        )
+        
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'\tfov_x: {fov_x}\n' + \
+            f'\tfov_y: {fov_y}\n' + \
+            f'\tnear: {near}\n' + \
+            f'\tfar: {far}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'
+        

utils3d/test/numpy_/transforms/linearize_depth.py

@@ -0,0 +1,34 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import glm
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+        near = np.random.uniform(0.1, 100, spatial)
+        far = np.random.uniform(near*2, 1000, spatial)
+        depth = np.random.uniform(near, far, spatial)
+        
+        expected = depth
+        
+        actual = utils3d.numpy.depth_buffer_to_linear(
+            utils3d.numpy.project_depth(depth, near, far),
+            near, far
+        )
+        
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'\tdepth: {depth}\n' + \
+            f'\tnear: {near}\n' + \
+            f'\tfar: {far}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/numpy_/transforms/normalize_intrinsic.py

@@ -0,0 +1,32 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+        fov = np.random.uniform(5 / 180 * np.pi, 175 / 180 * np.pi, spatial)
+        width = np.random.uniform(1, 10000, spatial)
+        height = np.random.uniform(1, 10000, spatial)
+        fov_x = np.where(width >= height, fov, 2 * np.arctan(np.tan(fov / 2) * width / height))
+        fov_y = np.where(width >= height, 2 * np.arctan(np.tan(fov / 2) * height / width), fov)
+
+        expected = utils3d.numpy.intrinsics_from_fov_xy(fov_x, fov_y)
+
+        actual = utils3d.numpy.normalize_intrinsics(utils3d.numpy.intrinsics_from_fov(fov, width, height), width, height)
+
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'\tfov: {fov}\n' + \
+            f'\twidth: {width}\n' + \
+            f'\theight: {height}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/numpy_/transforms/perspective.py

@@ -0,0 +1,36 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import glm
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+        fovy = np.random.uniform(5 / 180 * np.pi, 175 / 180 * np.pi, spatial)
+        aspect = np.random.uniform(0.01, 100, spatial)
+        near = np.random.uniform(0.1, 100, spatial)
+        far = np.random.uniform(near*2, 1000, spatial)
+        
+        expected = []
+        for i in range(np.prod(spatial) if len(spatial) > 0 else 1):
+            expected.append(glm.perspective(fovy.flat[i], aspect.flat[i], near.flat[i], far.flat[i]))
+        expected = np.concatenate(expected, axis=0).reshape(*spatial, 4, 4)
+        
+        actual = utils3d.numpy.perspective(fovy, aspect, near, far)
+        
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'\tfovy: {fovy}\n' + \
+            f'\taspect: {aspect}\n' + \
+            f'\tnear: {near}\n' + \
+            f'\tfar: {far}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/numpy_/transforms/perspective_from_fov.py

@@ -0,0 +1,40 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import glm
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+        fov = np.random.uniform(5 / 180 * np.pi, 175 / 180 * np.pi, spatial)
+        width = np.random.uniform(1, 10000, spatial)
+        height = np.random.uniform(1, 10000, spatial)
+        near = np.random.uniform(0.1, 100, spatial)
+        far = np.random.uniform(near*2, 1000, spatial)
+
+        fov_y = 2 * np.arctan(np.tan(fov / 2) * height / np.maximum(width, height))
+        expected = []
+        for i in range(np.prod(spatial) if len(spatial) > 0 else 1):
+            expected.append(glm.perspective(fov_y.flat[i], width.flat[i] / height.flat[i], near.flat[i], far.flat[i]))
+        expected = np.concatenate(expected, axis=0).reshape(*spatial, 4, 4)
+
+        actual = utils3d.numpy.perspective_from_fov(fov, width, height, near, far)
+        
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'\tfov: {fov}\n' + \
+            f'\twidth: {width}\n' + \
+            f'\theight: {height}\n' + \
+            f'\tnear: {near}\n' + \
+            f'\tfar: {far}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'
+        

utils3d/test/numpy_/transforms/perspective_from_fov_xy.py

@@ -0,0 +1,37 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import glm
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+        fov_x = np.random.uniform(5 / 180 * np.pi, 175 / 180 * np.pi, spatial)
+        fov_y = np.random.uniform(5 / 180 * np.pi, 175 / 180 * np.pi, spatial)
+        near = np.random.uniform(0.1, 100, spatial)
+        far = np.random.uniform(near*2, 1000, spatial)
+
+        aspect = np.tan(fov_x / 2) / np.tan(fov_y / 2)
+        expected = []
+        for i in range(np.prod(spatial) if len(spatial) > 0 else 1):
+            expected.append(glm.perspective(fov_y.flat[i], aspect.flat[i], near.flat[i], far.flat[i]))
+        expected = np.concatenate(expected, axis=0).reshape(*spatial, 4, 4)
+
+        actual = utils3d.numpy.perspective_from_fov_xy(fov_x, fov_y, near, far)
+        
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'\tfov_x: {fov_x}\n' + \
+            f'\tfov_y: {fov_y}\n' + \
+            f'\tnear: {near}\n' + \
+            f'\tfar: {far}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/numpy_/transforms/perspective_to_intrinsic.py

@@ -0,0 +1,36 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import glm
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+        fov_x = np.random.uniform(5 / 180 * np.pi, 175 / 180 * np.pi, spatial)
+        fov_y = np.random.uniform(5 / 180 * np.pi, 175 / 180 * np.pi, spatial)
+        near = np.random.uniform(0.1, 100)
+        far = np.random.uniform(near*2, 1000)
+
+        expected = utils3d.numpy.intrinsics_from_fov_xy(fov_x, fov_y)
+
+        actual = utils3d.numpy.perspective_to_intrinsics(
+            utils3d.numpy.perspective_from_fov_xy(fov_x, fov_y, near, far)
+        )
+        
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'\tfov_x: {fov_x}\n' + \
+            f'\tfov_y: {fov_y}\n' + \
+            f'\tnear: {near}\n' + \
+            f'\tfar: {far}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'
+        

utils3d/test/numpy_/transforms/pixel_to_ndc.py

@@ -0,0 +1,32 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+
+def run():
+    for i in range(100):
+        H = np.random.randint(1, 1000)
+        W = np.random.randint(1, 1000)
+        x, y = np.meshgrid(np.arange(W), np.arange(H), indexing='xy')
+        pixel = np.stack([x, y], axis=-1)
+        
+        expected = np.stack(
+            np.meshgrid(
+                np.linspace(-1 + 1 / W, 1 - 1 / W, W),
+                np.linspace(1 - 1 / H, -1 + 1 / H, H),
+                indexing='xy'
+            ),
+            axis=-1
+        )
+  
+        actual = utils3d.numpy.pixel_to_ndc(pixel, W, H)
+        
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'\tH: {H}\n' + \
+            f'\tW: {W}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/numpy_/transforms/pixel_to_uv.py

@@ -0,0 +1,32 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+
+def run():
+    for i in range(100):
+        H = np.random.randint(1, 1000)
+        W = np.random.randint(1, 1000)
+        x, y = np.meshgrid(np.arange(W), np.arange(H), indexing='xy')
+        pixel = np.stack([x, y], axis=-1)
+        
+        expected = np.stack(
+            np.meshgrid(
+                np.linspace(0.5 / W, 1 - 0.5 / W, W),
+                np.linspace(0.5 / H, 1 - 0.5 / H, H),
+                indexing='xy'
+            ),
+            axis=-1
+        )
+  
+        actual = utils3d.numpy.pixel_to_uv(pixel, W, H)
+        
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'\tH: {H}\n' + \
+            f'\tW: {W}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/numpy_/transforms/project_cv.py

@@ -0,0 +1,57 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import glm
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+            N = 1
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+            N = np.random.randint(1, 10)
+        focal_x = np.random.uniform(0, 10, spatial)
+        focal_y = np.random.uniform(0, 10, spatial)
+        center_x = np.random.uniform(0, 1, spatial)
+        center_y = np.random.uniform(0, 1, spatial)
+        eye = np.random.uniform(-10, 10, [*spatial, 3])
+        lookat = np.random.uniform(-10, 10, [*spatial, 3])
+        up = np.random.uniform(-10, 10, [*spatial, 3])
+        points = np.random.uniform(-10, 10, [*spatial, N, 3])
+
+        pts = points - eye[..., None, :]
+        z_axis = lookat - eye
+        x_axis = np.cross(-up, z_axis)
+        y_axis = np.cross(z_axis, x_axis)
+        x_axis = x_axis / np.linalg.norm(x_axis, axis=-1, keepdims=True)
+        y_axis = y_axis / np.linalg.norm(y_axis, axis=-1, keepdims=True)
+        z_axis = z_axis / np.linalg.norm(z_axis, axis=-1, keepdims=True)
+        z = (pts * z_axis[..., None, :]).sum(axis=-1)
+        x = (pts * x_axis[..., None, :]).sum(axis=-1)
+        y = (pts * y_axis[..., None, :]).sum(axis=-1)
+        x = (x / z * focal_x[..., None] + center_x[..., None])
+        y = (y / z * focal_y[..., None] + center_y[..., None])
+        expected = np.stack([x, y], axis=-1)
+        
+        actual, _ = utils3d.numpy.transforms.project_cv(points,
+                                            utils3d.numpy.extrinsics_look_at(eye, lookat, up),
+                                            utils3d.numpy.intrinsics(focal_x, focal_y, center_x, center_y))
+        
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'\tfocal_x: {focal_x}\n' + \
+            f'\tfocal_y: {focal_y}\n' + \
+            f'\tcenter_x: {center_x}\n' + \
+            f'\tcenter_y: {center_y}\n' + \
+            f'\teye: {eye}\n' + \
+            f'\tlookat: {lookat}\n' + \
+            f'\tup: {up}\n' + \
+            f'\tpoints: {points}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/numpy_/transforms/project_depth.py

@@ -0,0 +1,32 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import glm
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+        near = np.random.uniform(0.1, 100, spatial)
+        far = np.random.uniform(near*2, 1000, spatial)
+        depth = np.random.uniform(near, far, spatial)
+        
+        proj = utils3d.numpy.perspective(1.0, 1.0, near, far)[..., 2, 2:4]
+        expected = ((proj[..., 0] * -depth + proj[..., 1]) / depth) * 0.5 + 0.5
+        
+        actual = utils3d.numpy.project_depth(depth, near, far)
+        
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'\tdepth: {depth}\n' + \
+            f'\tnear: {near}\n' + \
+            f'\tfar: {far}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/numpy_/transforms/project_gl.py

@@ -0,0 +1,58 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import glm
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+            N = 1
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+            N = np.random.randint(1, 10)
+        fovy = np.random.uniform(5 / 180 * np.pi, 175 / 180 * np.pi, spatial)
+        aspect = np.random.uniform(0.01, 100, spatial)
+        near = np.random.uniform(0.1, 100, spatial)
+        far = np.random.uniform(near*2, 1000, spatial)
+        eye = np.random.uniform(-10, 10, [*spatial, 3])
+        lookat = np.random.uniform(-10, 10, [*spatial, 3])
+        up = np.random.uniform(-10, 10, [*spatial, 3])
+        points = np.random.uniform(-10, 10, [*spatial, N, 3])
+
+        pts = points - eye[..., None, :]
+        z_axis = (eye - lookat)
+        x_axis = np.cross(up, z_axis)
+        y_axis = np.cross(z_axis, x_axis)
+        x_axis = x_axis / np.linalg.norm(x_axis, axis=-1, keepdims=True)
+        y_axis = y_axis / np.linalg.norm(y_axis, axis=-1, keepdims=True)
+        z_axis = z_axis / np.linalg.norm(z_axis, axis=-1, keepdims=True)
+        z = (pts * z_axis[..., None, :]).sum(axis=-1)
+        x = (pts * x_axis[..., None, :]).sum(axis=-1)
+        y = (pts * y_axis[..., None, :]).sum(axis=-1)
+        x = (x / -z / np.tan(fovy[..., None] / 2) / aspect[..., None]) * 0.5 + 0.5
+        y = (y / -z / np.tan(fovy[..., None] / 2)) * 0.5 + 0.5
+        z = utils3d.numpy.project_depth(-z, near[..., None], far[..., None])
+        expected = np.stack([x, y, z], axis=-1)
+        
+        actual, _ = utils3d.numpy.transforms.project_gl(points, None,
+                                          utils3d.numpy.view_look_at(eye, lookat, up),
+                                          utils3d.numpy.perspective(fovy, aspect, near, far))
+        
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'\tfovy: {fovy}\n' + \
+            f'\taspect: {aspect}\n' + \
+            f'\tnear: {near}\n' + \
+            f'\tfar: {far}\n' + \
+            f'\teye: {eye}\n' + \
+            f'\tlookat: {lookat}\n' + \
+            f'\tup: {up}\n' + \
+            f'\tpoints: {points}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/numpy_/transforms/project_gl_cv.py

@@ -0,0 +1,52 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import glm
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+            N = 1
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+            N = np.random.randint(1, 10)
+        fovy = np.random.uniform(5 / 180 * np.pi, 175 / 180 * np.pi, spatial)
+        aspect = np.random.uniform(0.01, 100, spatial)
+        focal_x = 0.5 / (np.tan(fovy / 2) * aspect)
+        focal_y = 0.5 / np.tan(fovy / 2)
+        near = np.random.uniform(0.1, 100, spatial)
+        far = np.random.uniform(near*2, 1000, spatial)
+        eye = np.random.uniform(-10, 10, [*spatial, 3])
+        lookat = np.random.uniform(-10, 10, [*spatial, 3])
+        up = np.random.uniform(-10, 10, [*spatial, 3])
+        points = np.random.uniform(-10, 10, [*spatial, N, 3])
+
+        gl = utils3d.numpy.transforms.project_gl(points, None,
+                                    utils3d.numpy.view_look_at(eye, lookat, up),
+                                    utils3d.numpy.perspective(fovy, aspect, near, far))
+        gl_uv = gl[0][..., :2]
+        gl_uv[..., 1] = 1 - gl_uv[..., 1]
+        gl_depth = gl[1]
+        
+        cv = utils3d.numpy.transforms.project_cv(points,
+                                    utils3d.numpy.extrinsics_look_at(eye, lookat, up),
+                                    utils3d.numpy.intrinsics(focal_x, focal_y, 0.5, 0.5))
+        cv_uv = cv[0][..., :2]
+        cv_depth = cv[1]
+        
+        assert np.allclose(gl_uv, cv_uv) and np.allclose(gl_depth, cv_depth), '\n' + \
+            'Input:\n' + \
+            f'\tfovy: {fovy}\n' + \
+            f'\taspect: {aspect}\n' + \
+            f'\teye: {eye}\n' + \
+            f'\tlookat: {lookat}\n' + \
+            f'\tup: {up}\n' + \
+            f'\tpoints: {points}\n' + \
+            'GL:\n' + \
+            f'{gl}\n' + \
+            'CV:\n' + \
+            f'{cv}'

utils3d/test/numpy_/transforms/unproject_cv.py

@@ -0,0 +1,49 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import glm
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+            N = 1
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+            N = np.random.randint(1, 10)
+        focal_x = np.random.uniform(0, 10, spatial)
+        focal_y = np.random.uniform(0, 10, spatial)
+        center_x = np.random.uniform(0, 1, spatial)
+        center_y = np.random.uniform(0, 1, spatial)
+        eye = np.random.uniform(-10, 10, [*spatial, 3])
+        lookat = np.random.uniform(-10, 10, [*spatial, 3])
+        up = np.random.uniform(-10, 10, [*spatial, 3])
+        points = np.random.uniform(-10, 10, [*spatial, N, 3])
+
+        expected = points
+        
+        actual = utils3d.numpy.transforms.unproject_cv(
+            *utils3d.numpy.transforms.project_cv(points,
+                                     utils3d.numpy.transforms.extrinsics_look_at(eye, lookat, up),
+                                     utils3d.numpy.transforms.intrinsics(focal_x, focal_y, center_x, center_y)),
+            utils3d.numpy.transforms.extrinsics_look_at(eye, lookat, up),
+            utils3d.numpy.transforms.intrinsics(focal_x, focal_y, center_x, center_y)
+        )
+        
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'\tfocal_x: {focal_x}\n' + \
+            f'\tfocal_y: {focal_y}\n' + \
+            f'\tcenter_x: {center_x}\n' + \
+            f'\tcenter_y: {center_y}\n' + \
+            f'\teye: {eye}\n' + \
+            f'\tlookat: {lookat}\n' + \
+            f'\tup: {up}\n' + \
+            f'\tpoints: {points}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/numpy_/transforms/unproject_gl.py

@@ -0,0 +1,50 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import glm
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+            N = 1
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+            N = np.random.randint(1, 10)
+        fovy = np.random.uniform(5 / 180 * np.pi, 175 / 180 * np.pi, spatial)
+        aspect = np.random.uniform(0.01, 100, spatial)
+        near = np.random.uniform(0.1, 100, spatial)
+        far = np.random.uniform(near*2, 1000, spatial)
+        eye = np.random.uniform(-10, 10, [*spatial, 3])
+        lookat = np.random.uniform(-10, 10, [*spatial, 3])
+        up = np.random.uniform(-10, 10, [*spatial, 3])
+        points = np.random.uniform(-10, 10, [*spatial, N, 3])
+
+        expected = points
+        
+        actual = utils3d.numpy.transforms.unproject_gl(
+            utils3d.numpy.transforms.project_gl(points, None,
+                                      utils3d.numpy.view_look_at(eye, lookat, up),
+                                      utils3d.numpy.perspective(fovy, aspect, near, far))[0],
+            None,
+            utils3d.numpy.view_look_at(eye, lookat, up),
+            utils3d.numpy.perspective(fovy, aspect, near, far)
+        )
+        
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'\tfovy: {fovy}\n' + \
+            f'\taspect: {aspect}\n' + \
+            f'\tnear: {near}\n' + \
+            f'\tfar: {far}\n' + \
+            f'\teye: {eye}\n' + \
+            f'\tlookat: {lookat}\n' + \
+            f'\tup: {up}\n' + \
+            f'\tpoints: {points}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/numpy_/transforms/view_look_at.py

@@ -0,0 +1,39 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import glm
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+        eye = np.random.uniform(-10, 10, [*spatial, 3]).astype(np.float32)
+        lookat = np.random.uniform(-10, 10, [*spatial, 3]).astype(np.float32)
+        up = np.random.uniform(-10, 10, [*spatial, 3]).astype(np.float32)
+
+        expected = []
+        for i in range(np.prod(spatial) if len(spatial) > 0 else 1):
+            expected.append(np.array(glm.lookAt(
+                glm.vec3(eye.reshape([-1, 3])[i]),
+                glm.vec3(lookat.reshape([-1, 3])[i]),
+                glm.vec3(up.reshape([-1, 3])[i])
+            )))
+        expected = np.concatenate(expected, axis=0).reshape([*spatial, 4, 4])
+
+        actual = utils3d.numpy.view_look_at(eye, lookat, up)
+        
+        assert np.allclose(expected, actual, 1e-5, 1e-5), '\n' + \
+            'Input:\n' + \
+            f'eye: {eye}\n' + \
+            f'lookat: {lookat}\n' + \
+            f'up: {up}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'
+        

utils3d/test/numpy_/transforms/view_to_extrinsic.py

@@ -0,0 +1,32 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import glm
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+        eye = np.random.uniform(-10, 10, [*spatial, 3]).astype(np.float32)
+        lookat = np.random.uniform(-10, 10, [*spatial, 3]).astype(np.float32)
+        up = np.random.uniform(-10, 10, [*spatial, 3]).astype(np.float32)
+
+        expected = utils3d.numpy.extrinsics_look_at(eye, lookat, up)
+
+        actual = utils3d.numpy.view_to_extrinsics(utils3d.numpy.view_look_at(eye, lookat, up))
+        
+        assert np.allclose(expected, actual, 1e-5, 1e-5), '\n' + \
+            'Input:\n' + \
+            f'eye: {eye}\n' + \
+            f'lookat: {lookat}\n' + \
+            f'up: {up}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'
+        

utils3d/test/numpy_/utils/image_mesh.py

@@ -0,0 +1,32 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+
+def run():
+    args = [
+        {'W':2, 'H':2, 'backslash': np.array([False])},
+        {'W':2, 'H':2, 'backslash': np.array([True])},
+        {'H':2, 'W':3, 'backslash': np.array([True, False])},
+    ]
+
+    expected = [
+        np.array([[0, 2, 1], [1, 2, 3]]),
+        np.array([[0, 2, 3], [0, 3, 1]]),
+        np.array([[0, 3, 4], [0, 4, 1], [1, 4, 2], [2, 4, 5]]),
+    ]
+
+    for args, expected in zip(args, expected):
+        actual = utils3d.numpy.triangulate(
+            utils3d.numpy.image_mesh(args['H'], args['W'])[1],
+            backslash=args.get('backslash', None),
+        )
+                    
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'{args}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/rasterization_/gl/basic.py

@@ -0,0 +1,70 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import moderngl
+import numpy as np
+from PIL import Image
+from pyrr import Matrix44
+
+# -------------------
+# CREATE CONTEXT HERE
+# -------------------
+
+import moderngl
+
+def run():
+    ctx = moderngl.create_context(
+        standalone=True,
+        backend='egl',
+        # These are OPTIONAL if you want to load a specific version
+        libgl='libGL.so.1',
+        libegl='libEGL.so.1',
+    )
+
+    prog = ctx.program(vertex_shader="""
+        #version 330
+        uniform mat4 model;
+        in vec2 in_vert;
+        in vec3 in_color;
+        out vec3 color;
+        void main() {
+            gl_Position = model * vec4(in_vert, 0.0, 1.0);
+            color = in_color;
+        }
+        """,
+        fragment_shader="""
+        #version 330
+        in vec3 color;
+        out vec4 fragColor;
+        void main() {
+            fragColor = vec4(color, 1.0);
+        }
+    """)
+
+    vertices = np.array([
+        -0.6, -0.6,
+        1.0, 0.0, 0.0,
+        0.6, -0.6,
+        0.0, 1.0, 0.0,
+        0.0, 0.6,
+        0.0, 0.0, 1.0,
+    ], dtype='f4')
+
+    vbo = ctx.buffer(vertices)
+    vao = ctx.simple_vertex_array(prog, vbo, 'in_vert', 'in_color')
+    fbo = ctx.framebuffer(color_attachments=[ctx.texture((512, 512), 4)])
+
+    fbo.use()
+    ctx.clear()
+    prog['model'].write(Matrix44.from_eulers((0.0, 0.1, 0.0), dtype='f4'))
+    vao.render(moderngl.TRIANGLES)
+
+    data = fbo.read(components=3)
+    image = Image.frombytes('RGB', fbo.size, data)
+    image = image.transpose(Image.FLIP_TOP_BOTTOM)
+    image.save(os.path.join(os.path.dirname(__file__), '..', '..', 'results_to_check', 'output.png'))
+
+
+if __name__ == '__main__':
+    run()

utils3d/test/rasterization_/gl/rasterize_uv.py

@@ -0,0 +1,42 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import imageio
+
+def run():
+    image_uv, image_mesh = utils3d.numpy.utils.image_mesh(128, 128)
+    image_mesh = image_mesh.reshape(-1, 4)
+    depth = np.ones((128, 128), dtype=np.float32) * 2
+    depth[32:96, 32:96] = 1
+    depth = depth.reshape(-1)
+    intrinsics = utils3d.numpy.transforms.intrinsics_from_fov(1.0, 128, 128).astype(np.float32)
+    intrinsics = utils3d.numpy.transforms.normalize_intrinsics(intrinsics, 128, 128)
+    extrinsics = utils3d.numpy.transforms.extrinsics_look_at([0, 0, 1], [0, 0, 0], [0, 1, 0]).astype(np.float32)
+    pts = utils3d.numpy.transforms.unproject_cv(image_uv, depth, extrinsics, intrinsics)
+    pts = pts.reshape(-1, 3)
+    image_mesh = utils3d.numpy.mesh.triangulate(image_mesh, vertices=pts)
+    
+    perspective = utils3d.numpy.transforms.perspective(1.0, 1.0, 0.1, 10)
+    view = utils3d.numpy.transforms.view_look_at([1, 0, 1], [0, 0, 0], [0, 1, 0])
+    mvp = np.matmul(perspective, view)
+    ctx = utils3d.numpy.rasterization.RastContext(
+        standalone=True,
+        backend='egl',
+        device_index=0,
+    )
+    uv = utils3d.numpy.rasterization.rasterize_triangle_faces(
+        ctx,
+        pts,
+        image_mesh,
+        image_uv,
+        width=128,
+        height=128,
+        mvp=mvp,
+    )[0]
+    uv = (np.concatenate([uv, np.zeros((128, 128, 1), dtype=np.float32)], axis=-1) * 255).astype(np.uint8)
+    imageio.imwrite(os.path.join(os.path.dirname(__file__), '..', '..', 'results_to_check', 'rasterize_uv.png'), uv)
+
+if __name__ == '__main__':
+    run()

utils3d/test/test.py

@@ -0,0 +1,50 @@
+import importlib
+import os
+import torch
+import traceback
+
+CRED    = '\033[91m'
+CGREEN  = '\033[92m'
+CEND    = '\033[0m'
+
+if __name__ == '__main__':
+    # list all tests
+    tests = []
+    for root, dirs, files in os.walk('test'):
+        if root == 'test':
+            continue
+        for file in files:
+            if file.endswith('.py'):
+                root = root.replace('test/', '').replace('test\\', '')
+                test = os.path.join(root, file)
+                test = test.replace('/', '.').replace('\\', '.').replace('.py', '')
+                tests.append(test)
+    tests.sort()
+    print(f'Found {len(tests)} tests:')
+    for test in tests:
+        print(f'  {test}')
+    print()
+
+    # disable torch optimizations
+    torch.backends.cudnn.enabled = False
+    torch.backends.cuda.matmul.allow_tf32 = False
+
+    # import and run
+    passed = 0
+    for test in tests:
+        print(f'Running test: {test}... ', end='')
+        test = importlib.import_module(test, '.'.join(test.split('.')[:-1]))
+        try:
+            test.run()
+        except Exception as e:
+            print(CRED, end='')
+            print('Failed')
+            traceback.print_exc()
+        else:
+            print(CGREEN, end='')
+            print('Passed')
+            passed += 1
+        print(CEND, end='')
+
+    print(f'Passed {passed}/{len(tests)} tests')
+    

utils3d/test/torch_/mesh/compute_face_angle.py

@@ -0,0 +1,39 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import torch
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+            vertices = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0]], dtype=float)
+            faces = np.array([[0, 1, 2]])
+            expected = np.array([[np.pi/2, np.pi/4, np.pi/4]])
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+            N = np.random.randint(100, 1000)
+            vertices = np.random.rand(*spatial, N, 3)
+            L = np.random.randint(1, 1000)
+            faces = np.random.randint(0, N, size=(*spatial, L, 3))
+            faces[..., 1] = (faces[..., 0] + 1) % N
+            faces[..., 2] = (faces[..., 0] + 2) % N
+
+        expected = utils3d.numpy.compute_face_angle(vertices, faces)
+
+        device = [torch.device('cpu'), torch.device('cuda')][np.random.randint(2)]
+        vertices = torch.tensor(vertices, device=device)
+        faces = torch.tensor(faces, device=device)
+
+        actual = utils3d.torch.compute_face_angle(vertices, faces).cpu().numpy()        
+        
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'{faces}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/torch_/mesh/compute_face_normal.py

@@ -0,0 +1,39 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import torch
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+            vertices = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0]], dtype=float)
+            faces = np.array([[0, 1, 2]])
+            expected = np.array([[0, 0, 1]])
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+            N = np.random.randint(100, 1000)
+            vertices = np.random.rand(*spatial, N, 3)
+            L = np.random.randint(1, 1000)
+            faces = np.random.randint(0, N, size=(*spatial, L, 3))
+            faces[..., 1] = (faces[..., 0] + 1) % N
+            faces[..., 2] = (faces[..., 0] + 2) % N
+
+        expected = utils3d.numpy.compute_face_normal(vertices, faces)
+
+        device = [torch.device('cpu'), torch.device('cuda')][np.random.randint(2)]
+        vertices = torch.tensor(vertices, device=device)
+        faces = torch.tensor(faces, device=device)
+
+        actual = utils3d.torch.compute_face_normal(vertices, faces).cpu().numpy()
+        
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'{faces}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/torch_/mesh/compute_vertex_normal.py

@@ -0,0 +1,39 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import torch
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+            vertices = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0]], dtype=float)
+            faces = np.array([[0, 1, 2]])
+            expected = np.array([[0, 0, 1], [0, 0, 1], [0, 0, 1]])
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+            N = np.random.randint(100, 1000)
+            vertices = np.random.rand(*spatial, N, 3)
+            L = np.random.randint(1, 1000)
+            faces = np.random.randint(0, N, size=(*spatial, L, 3))
+            faces[..., 1] = (faces[..., 0] + 1) % N
+            faces[..., 2] = (faces[..., 0] + 2) % N
+
+        expected = utils3d.numpy.compute_vertex_normal(vertices, faces)
+
+        device = [torch.device('cpu'), torch.device('cuda')][np.random.randint(2)]
+        vertices = torch.tensor(vertices, device=device)
+        faces = torch.tensor(faces, device=device)
+
+        actual = utils3d.torch.compute_vertex_normal(vertices, faces).cpu().numpy()
+        
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'{faces}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/torch_/mesh/compute_vertex_normal_weighted.py

@@ -0,0 +1,39 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import torch
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+            vertices = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0]], dtype=float)
+            faces = np.array([[0, 1, 2]])
+            expected = np.array([[0, 0, 1], [0, 0, 1], [0, 0, 1]])
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+            N = np.random.randint(100, 1000)
+            vertices = np.random.rand(*spatial, N, 3)
+            L = np.random.randint(1, 1000)
+            faces = np.random.randint(0, N, size=(*spatial, L, 3))
+            faces[..., 1] = (faces[..., 0] + 1) % N
+            faces[..., 2] = (faces[..., 0] + 2) % N
+
+        expected = utils3d.numpy.compute_vertex_normal_weighted(vertices, faces)
+
+        device = [torch.device('cpu'), torch.device('cuda')][np.random.randint(2)]
+        vertices = torch.tensor(vertices, device=device)
+        faces = torch.tensor(faces, device=device)
+
+        actual = utils3d.torch.compute_vertex_normal_weighted(vertices, faces).cpu().numpy()
+
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'{faces}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/torch_/mesh/merge_duplicate_vertices.py

@@ -0,0 +1,44 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import torch
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+            vertices = np.array([[0, 0, 0], [1, 0, 0], [1, 0, 0]], dtype=float)
+            faces = np.array([[0, 1, 2]])
+            expected_vertices = np.array([[0, 0, 0], [1, 0, 0]])
+            expected_faces = np.array([[0, 1, 1]])
+            expected = expected_vertices[expected_faces]
+        else:
+            N = np.random.randint(100, 1000)
+            vertices = np.random.rand(N, 3)
+            L = np.random.randint(1, 1000)
+            faces = np.random.randint(0, N, size=(L, 3))
+            faces[..., 1] = (faces[..., 0] + 1) % N
+            faces[..., 2] = (faces[..., 0] + 2) % N
+            vertices[-(N//2):] = vertices[:N//2]
+
+        expected_vertices, expected_faces = utils3d.numpy.merge_duplicate_vertices(vertices, faces)
+        expected = expected_vertices[expected_faces]
+
+        device = [torch.device('cpu'), torch.device('cuda')][np.random.randint(2)]
+        vertices = torch.tensor(vertices, device=device)
+        faces = torch.tensor(faces, device=device)
+
+        actual_vertices, actual_faces = utils3d.torch.merge_duplicate_vertices(vertices, faces)
+        actual_vertices = actual_vertices.cpu().numpy()
+        actual_faces = actual_faces.cpu().numpy()
+        actual = actual_vertices[actual_faces]
+                    
+        assert expected_vertices.shape == actual_vertices.shape and np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'{faces}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/torch_/mesh/remove_corrupted_faces.py

@@ -0,0 +1,33 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import torch
+
+def run():
+    for i in range(100):
+        if i == 0:
+            faces = np.array([[0, 1, 2], [0, 2, 2], [0, 2, 3]])
+            expected = np.array([[0, 1, 2], [0, 2, 3]])
+        else:
+            L = np.random.randint(1, 1000)
+            N = np.random.randint(100, 1000)
+            faces = np.random.randint(0, N, size=(L, 3))
+            faces[..., 1] = (faces[..., 0] + 1) % N
+            faces[..., 2] = (faces[..., 0] + 2) % N
+
+        expected = utils3d.numpy.remove_corrupted_faces(faces)
+
+        device = [torch.device('cpu'), torch.device('cuda')][np.random.randint(2)]
+        faces = torch.tensor(faces, device=device)
+
+        actual = utils3d.torch.remove_corrupted_faces(faces).cpu().numpy()
+        
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'{faces}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/torch_/mesh/triangulate.py

@@ -0,0 +1,36 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import torch
+
+def run():
+    for i in range(100):
+        if i == 0:
+            spatial = []
+            L = 1
+            N = 5
+            faces = np.array([[0, 1, 2, 3, 4]])
+            expected = np.array([[0, 1, 2], [0, 2, 3], [0, 3, 4]])
+        else:
+            dim = np.random.randint(4)
+            spatial = [np.random.randint(1, 10) for _ in range(dim)]
+            L = np.random.randint(1, 1000)
+            N = np.random.randint(3, 10)
+            faces = np.random.randint(0, 10000, size=(*spatial, L, N))
+
+        expected = utils3d.numpy.triangulate(faces)
+
+        device = [torch.device('cpu'), torch.device('cuda')][np.random.randint(2)]
+        faces = torch.tensor(faces, device=device)
+        
+        actual = utils3d.torch.triangulate(faces).cpu().numpy()
+        
+        assert np.allclose(expected, actual), '\n' + \
+            'Input:\n' + \
+            f'{faces}\n' + \
+            'Actual:\n' + \
+            f'{actual}\n' + \
+            'Expected:\n' + \
+            f'{expected}'

utils3d/test/torch_/rasterization/warp_image_by_depth.py

@@ -0,0 +1,30 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')))
+import utils3d
+import numpy as np
+import torch
+import imageio
+
+def run():
+    depth = torch.ones((1, 128, 128), dtype=torch.float32, device='cuda') * 2
+    depth[:, 32:48, 32:48] = 1
+    intrinsics = utils3d.torch.transforms.intrinsics(1.0, 1.0, 0.5, 0.5).to(depth)
+    extrinsics_src = utils3d.torch.transforms.extrinsics_look_at([0., 0., 1.], [0., 0., 0.], [0., 1., 0.]).to(depth)
+    extrinsics_tgt = utils3d.torch.transforms.extrinsics_look_at([1., 0., 1.], [0., 0., 0.], [0., 1., 0.]).to(depth)
+    ctx = utils3d.torch.rasterization.RastContext(backend='gl', device='cuda')
+    uv, _ = utils3d.torch.rasterization.warp_image_by_depth(
+        ctx,
+        depth,
+        extrinsics_src=extrinsics_src,
+        extrinsics_tgt=extrinsics_tgt,
+        intrinsics_src=intrinsics,
+        antialiasing=False,
+    )
+    uv = torch.cat([uv, torch.zeros((1, 1, 128, 128)).to(uv)], dim=1) * 255
+    uv = uv.permute(0, 2, 3, 1).squeeze().cpu().numpy().astype(np.uint8)
+
+    imageio.imwrite(os.path.join(os.path.dirname(__file__), '..', '..', 'results_to_check', 'torch_warp_image_uv.png'), uv)
+
+if __name__ == '__main__':
+    run()