feat: Add beartype for runtime type checking and update dependencies

- Add beartype dependency to pyproject.toml and uv.lock
- Replace typeguard with beartype in type checking
- Create camera module with type-safe camera parameter definitions
- Migrate utility function to use beartype and JAX numpy

app/camera/__init__.py

@@ -0,0 +1,54 @@
+from typing import TypedDict, TypeAlias, Any
+from typing_extensions import NotRequired
+
+from jaxtyping import Num, jaxtyped
+from beartype import beartype
+from jax import numpy as jnp, Array
+
+CameraID: TypeAlias = str
+
+
+@jaxtyped(typechecker=beartype)
+class CameraParams(TypedDict):
+    """
+    Camera parameters: intrinsic matrix, extrinsic matrix, and distortion coefficients
+    """
+
+    K: Num[Array, "3 3"]
+    """
+    intrinsic matrix
+    """
+    Rt: Num[Array, "4 4"]
+    """
+    [R|t] extrinsic matrix
+
+    R and t are the rotation and translation that describe the change of
+    coordinates from world to camera coordinate systems (or camera frame)
+    """
+    dist_coeffs: Num[Array, "N"]
+    """
+    An array of distortion coefficients of the form
+    [k1, k2, [p1, p2, [k3]]], where ki is the ith
+    radial distortion coefficient and pi is the ith
+    tangential distortion coeff.
+    """
+
+
+@jaxtyped(typechecker=beartype)
+class Camera(TypedDict):
+    """
+    a description of a camera
+    """
+
+    id: CameraID
+    """
+    Camera ID
+    """
+    params: CameraParams
+    """
+    Camera parameters
+    """
+    size: tuple[int, int]
+    """
+    Image size
+    """

app/utils/__init__.py

@@ -1,23 +1,21 @@
 from typing import Any
 
-import numpy as np
-from jaxtyping import Float, Num, jaxtyped
-from typeguard import typechecked
-
-from app._typing import NDArray
+from jaxtyping import Num, jaxtyped
+from beartype import beartype
+from jax import numpy as jnp, Array
 
 
-@jaxtyped(typechecker=typechecked)
+@jaxtyped(typechecker=beartype)
 def calculate_perpendicular_distance(
-    point: Num[NDArray, "2"],
-    line: Num[NDArray, "2 2"],
-) -> np.floating[Any]:
+    point: Num[Array, "2"],
+    line: Num[Array, "2 2"],
+) -> jnp.floating[Any]:
     """
     Calculate the perpendicular distance between a point and a line.
     """
     line_start, line_end = line
-    distance = np.linalg.norm(
-        np.cross(line_end - line_start, line_start - point)
-    ) / np.linalg.norm(line_end - line_start)
+    distance = jnp.linalg.norm(
+        jnp.cross(line_end - line_start, line_start - point)
+    ) / jnp.linalg.norm(line_end - line_start)
 
     return distance