improve typing

Author: falkoschindler

rosys/analysis/legacy/asyncio_page.py

@@ -2,6 +2,7 @@
 import logging
 
 import numpy as np
+import numpy.typing as npt
 from nicegui import ui
 
 from rosys import run
@@ -13,12 +14,13 @@
 
 def prepare_data(timings) -> tuple[list[str], list[dict[str, float]]]:
     def calc_box(data: list) -> dict[str, float]:
+        percentiles: npt.NDArray[np.floating] = np.percentile(data, [0, 25, 50, 75, 100])
         return {
-            'low': float(min(data)),
-            'q1': float(np.percentile(data, 25)),
-            'median': float(np.percentile(data, 50)),
-            'q3': float(np.percentile(data, 75)),
-            'high': float(max(data)),
+            'low': percentiles[0],
+            'q1': percentiles[1],
+            'median': percentiles[2],
+            'q3': percentiles[3],
+            'high': percentiles[4],
         }
     timings = dict(sorted(timings.items(), key=lambda i: len(i[1]), reverse=True))
     names = [f'{html.escape(n)} ({len(w)} warnings):<br>{html.escape(w[0].details)}' for n, w in timings.items()]

rosys/vision/calibration.py

@@ -163,10 +163,11 @@ def from_points(world_points: list[Point3d] | list[list[Point3d]],
         else:
             raise ValueError(f'Unknown camera model "{camera_model}"')
 
-        camera_matrix: list[list[float]] = K.tolist()  # type: ignore
-        distortion: list[float] = D.tolist()[0]  # type: ignore
-        intrinsics = Intrinsics(matrix=camera_matrix, distortion=distortion, size=image_size,
-                                model=camera_model, omnidir_params=OmnidirParameters(xi=xi))
+        intrinsics = Intrinsics(matrix=cast(np.ndarray, K).tolist(),
+                                distortion=cast(np.ndarray, D).tolist()[0],
+                                size=image_size,
+                                model=camera_model,
+                                omnidir_params=OmnidirParameters(xi=xi))
 
         rotation = Rotation.from_rvec(rvecs[0]).T
         translation = -np.array(rotation.R).dot(tvecs[0])
@@ -202,7 +203,8 @@ def project_to_image(self, coordinates: FloatArray, *, frame: Frame3d | None = N
         :return: (Nx2) The image coordinates of the projected points.
         """
 
-    def project_to_image(self, coordinates: Point3d | list[Point3d] | FloatArray, *, frame: Frame3d | None = None) -> Point | None | list[Point | None] | FloatArray:
+    def project_to_image(self, coordinates: Point3d | list[Point3d] | FloatArray, *,
+                         frame: Frame3d | None = None) -> Point | None | list[Point | None] | FloatArray:
 
         if isinstance(coordinates, Point3d):
             return self.project_to_image([coordinates])[0]

rosys/vision/image.py

@@ -89,16 +89,15 @@ def from_jpeg_bytes(cls, jpeg_bytes: bytes, *,
                         time: float | None = None,
                         metadata: dict[str, Any] | None = None) -> Self | None:
         """Create an image from plain JPEG bytes. This runs a jpeg decode. Returns None if decoding fails."""
-        decoded = decode_jpeg_image(jpeg_bytes)
-        if decoded is None:
+        array = decode_jpeg_image(jpeg_bytes)
+        if array is None:
             return None
-        array = decoded
         if len(array.shape) == 2:
             array = np.repeat(np.expand_dims(array, -1), repeats=3, axis=2)
         return cls.from_array(array, camera_id=camera_id, time=time, metadata=metadata)
 
     @classmethod
-    def from_array(cls, array: np.ndarray[Any, np.dtype[np.uint8]], *,
+    def from_array(cls, array: ImageArray, *,
                    camera_id: str = 'from_array',
                    time: float | None = None,
                    metadata: dict[str, Any] | None = None) -> Self:

rosys/vision/image_processing.py

@@ -8,6 +8,7 @@
 import PIL.Image
 
 from ..geometry import Rectangle
+from .image import ImageArray
 from .image_rotation import ImageRotation
 from .turbojpeg_wrapper import TURBO_JPEG
 
@@ -31,7 +32,7 @@ def encode_image_as_jpeg(image: np.ndarray, compression_level: int = 90) -> byte
     return buffer.getvalue()
 
 
-def decode_jpeg_image(jpeg_bytes: bytes) -> np.ndarray | None:
+def decode_jpeg_image(jpeg_bytes: bytes) -> ImageArray | None:
     """Decode JPEG bytes to NumPy array using TurboJPEG if available, otherwise PIL. Returns None if decoding failed."""
     try:
         if TURBO_JPEG is not None: