Format all files

A blanket 'ruff format'. Not all changes are exactly to my liking, but I
didn't see anything horrible either. And it's good to have clean code
that passes checks.

Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ideasonboard.com>

Author: tomba

pixutils/conv/conv.py

@@ -69,13 +69,15 @@ def to_bgr888(
     for backend in backends:
         if backend == 'opencv':
             from .opencv import opencv_to_bgr888
+
             result = opencv_to_bgr888(fmt, width, height, arr, options)
             if result is not None:
                 return result
             # opencv couldn't handle this format/options, try next backend
             continue
         elif backend == 'numba':
             from .numba import numba_to_bgr888
+
             result = numba_to_bgr888(fmt, width, height, bytesperline, arr, options)
             if result is not None:
                 return result

pixutils/conv/opencv.py

@@ -12,9 +12,16 @@
 
 _SUPPORTED_YUV_FORMATS = {'YUYV', 'UYVY', 'YVYU', 'NV12', 'NV21'}
 _SUPPORTED_RGB_FORMATS = {
-    'XRGB8888', 'BGRX8888', 'ARGB8888', 'BGRA8888',
-    'XBGR8888', 'RGBX8888', 'ABGR8888', 'RGBA8888',
-    'RGB888', 'BGR888',
+    'XRGB8888',
+    'BGRX8888',
+    'ARGB8888',
+    'BGRA8888',
+    'XBGR8888',
+    'RGBX8888',
+    'ABGR8888',
+    'RGBA8888',
+    'RGB888',
+    'BGR888',
 }
 
 
@@ -53,9 +60,9 @@ def _can_use_opencv_rgb(fmt: PixelFormat) -> bool:
     return fmt.name in _SUPPORTED_RGB_FORMATS
 
 
-def opencv_to_bgr888(fmt: PixelFormat, width: int, height: int,
-                     arr: npt.NDArray[np.uint8],
-                     options: dict | None) -> npt.NDArray[np.uint8] | None:
+def opencv_to_bgr888(
+    fmt: PixelFormat, width: int, height: int, arr: npt.NDArray[np.uint8], options: dict | None
+) -> npt.NDArray[np.uint8] | None:
     if fmt.color == PixelColorEncoding.YUV:
         if not _can_use_opencv_yuv(fmt, options):
             return None
@@ -70,4 +77,5 @@ def opencv_to_bgr888(fmt: PixelFormat, width: int, height: int,
 
     # Import and call implementation only if format is supported
     from .opencv_impl import opencv_convert
+
     return opencv_convert(fmt, width, height, arr)

pixutils/conv/opencv_impl.py

@@ -5,7 +5,7 @@
 
 from typing import Callable, cast
 
-import cv2 # type: ignore[import-not-found]
+import cv2  # type: ignore[import-not-found]
 import numpy as np
 import numpy.typing as npt
 
@@ -47,15 +47,17 @@
 }
 
 
-def _convert_yuv(fmt: PixelFormat, width: int, height: int,
-                 arr: npt.NDArray[np.uint8]) -> npt.NDArray[np.uint8]:
+def _convert_yuv(
+    fmt: PixelFormat, width: int, height: int, arr: npt.NDArray[np.uint8]
+) -> npt.NDArray[np.uint8]:
     cv_code, reshape_func = YUV_FORMAT_MAP[fmt.name]
     reshaped = reshape_func(arr, width, height)
     return cv2.cvtColor(reshaped, cv_code)
 
 
-def _convert_rgb(fmt: PixelFormat, width: int, height: int,
-                 arr: npt.NDArray[np.uint8]) -> npt.NDArray[np.uint8]:
+def _convert_rgb(
+    fmt: PixelFormat, width: int, height: int, arr: npt.NDArray[np.uint8]
+) -> npt.NDArray[np.uint8]:
     cv_code, reshape_func = RGB_FORMAT_MAP[fmt.name]
     reshaped = reshape_func(arr, width, height)
 
@@ -66,8 +68,9 @@ def _convert_rgb(fmt: PixelFormat, width: int, height: int,
     return cv2.cvtColor(reshaped, cv_code)
 
 
-def _convert_raw(fmt: PixelFormat, width: int, height: int,
-                 arr: npt.NDArray[np.uint8]) -> npt.NDArray[np.uint8] | None:
+def _convert_raw(
+    fmt: PixelFormat, width: int, height: int, arr: npt.NDArray[np.uint8]
+) -> npt.NDArray[np.uint8] | None:
     pattern = fmt.bayer_pattern
     assert pattern is not None
     cv_code = BAYER_PATTERN_MAP[pattern]
@@ -96,8 +99,9 @@ def _convert_raw(fmt: PixelFormat, width: int, height: int,
         return None
 
 
-def opencv_convert(fmt: PixelFormat, width: int, height: int,
-                   arr: npt.NDArray[np.uint8]) -> npt.NDArray[np.uint8] | None:
+def opencv_convert(
+    fmt: PixelFormat, width: int, height: int, arr: npt.NDArray[np.uint8]
+) -> npt.NDArray[np.uint8] | None:
     if fmt.color == PixelColorEncoding.YUV:
         return _convert_yuv(fmt, width, height, arr)
 

pixutils/conv/qt.py

@@ -20,12 +20,14 @@ def bgr888_to_pix(rgb: npt.NDArray[np.uint8]) -> QtGui.QPixmap:
 
     w = rgb.shape[1]
     h = rgb.shape[0]
-    qim = QtGui.QImage(rgb, w, h, QtGui.QImage.Format.Format_RGB888) # pylint: disable=no-member # type: ignore
+    qim = QtGui.QImage(rgb, w, h, QtGui.QImage.Format.Format_RGB888)  # pylint: disable=no-member # type: ignore
     pix = QtGui.QPixmap.fromImage(qim)
     return pix
 
 
-def buffer_to_pix(fmt: PixelFormat, w: int, h: int, bytesperline: int, buffer, options: None | dict = None) -> QtGui.QPixmap:
+def buffer_to_pix(
+    fmt: PixelFormat, w: int, h: int, bytesperline: int, buffer, options: None | dict = None
+) -> QtGui.QPixmap:
     if fmt == PixelFormats.MJPEG:
         pix = QtGui.QPixmap(w, h)
         pix.loadFromData(buffer)

pixutils/conv/raw.py

@@ -61,13 +61,16 @@ def from_pixelformat(cls, fmt: PixelFormat):
         else:
             bpp = int(name[5:])  # Direct BPP value
 
-        return cls(bayer_pattern=BayerPattern.from_pattern(pattern),
-                   bits_per_pixel=bpp,
-                   is_packed=is_packed)
+        return cls(
+            bayer_pattern=BayerPattern.from_pattern(pattern),
+            bits_per_pixel=bpp,
+            is_packed=is_packed,
+        )
 
 
-def prepare_packed_raw(data: npt.NDArray[np.uint8], width: int, height: int,
-                       bits_per_pixel: int, bytesperline: int) -> npt.NDArray[np.uint16]:
+def prepare_packed_raw(
+    data: npt.NDArray[np.uint8], width: int, height: int, bits_per_pixel: int, bytesperline: int
+) -> npt.NDArray[np.uint16]:
     assert bits_per_pixel in [10, 12], 'Only 10 and 12 bpp are supported'
 
     # Reshape into rows if bytesperline is provided
@@ -107,9 +110,9 @@ def _unpack_12bit(arr16: npt.NDArray[np.uint16]) -> npt.NDArray[np.uint16]:
     return np.delete(arr16_shifted, np.s_[2::3], 1)
 
 
-def prepare_unpacked_raw(data: npt.NDArray[np.uint8], width: int, height: int,
-                         bits_per_pixel: int, bytesperline: int) -> npt.NDArray[np.uint16]:
-
+def prepare_unpacked_raw(
+    data: npt.NDArray[np.uint8], width: int, height: int, bits_per_pixel: int, bytesperline: int
+) -> npt.NDArray[np.uint16]:
     # Reshape into rows if bytesperline is provided
     if bytesperline:
         data = data.reshape((len(data) // bytesperline, bytesperline))
@@ -151,15 +154,17 @@ def mosaic(data: npt.NDArray[np.uint16], pattern: BayerPattern) -> npt.NDArray[n
     # Create an empty RGB image with 3 channels
     rgb = np.zeros(data.shape + (3,), dtype=data.dtype)
 
-    rgb[pattern.r0[1]::2, pattern.r0[0]::2, 0] = data[pattern.r0[1]::2, pattern.r0[0]::2]
-    rgb[pattern.g0[1]::2, pattern.g0[0]::2, 1] = data[pattern.g0[1]::2, pattern.g0[0]::2]
-    rgb[pattern.g1[1]::2, pattern.g1[0]::2, 1] = data[pattern.g1[1]::2, pattern.g1[0]::2]
-    rgb[pattern.b0[1]::2, pattern.b0[0]::2, 2] = data[pattern.b0[1]::2, pattern.b0[0]::2]
+    rgb[pattern.r0[1] :: 2, pattern.r0[0] :: 2, 0] = data[pattern.r0[1] :: 2, pattern.r0[0] :: 2]
+    rgb[pattern.g0[1] :: 2, pattern.g0[0] :: 2, 1] = data[pattern.g0[1] :: 2, pattern.g0[0] :: 2]
+    rgb[pattern.g1[1] :: 2, pattern.g1[0] :: 2, 1] = data[pattern.g1[1] :: 2, pattern.g1[0] :: 2]
+    rgb[pattern.b0[1] :: 2, pattern.b0[0] :: 2, 2] = data[pattern.b0[1] :: 2, pattern.b0[0] :: 2]
 
     return rgb
 
 
-def demosaic(data: npt.NDArray[np.uint16], pattern: BayerPattern, options: None | dict = None) -> npt.NDArray[np.uint16]:
+def demosaic(
+    data: npt.NDArray[np.uint16], pattern: BayerPattern, options: None | dict = None
+) -> npt.NDArray[np.uint16]:
     # Select demosaic algorithm based on options
     method = options.get('demosaic_method', '3x3') if options else '3x3'
     h, w = data.shape
@@ -174,7 +179,9 @@ def demosaic(data: npt.NDArray[np.uint16], pattern: BayerPattern, options: None
         raise ValueError(f'Unknown demosaic method: {method}')
 
 
-def _demosaic_3x3_window(data: npt.NDArray[np.uint16], pattern: BayerPattern, h: int, w: int) -> npt.NDArray[np.uint16]:
+def _demosaic_3x3_window(
+    data: npt.NDArray[np.uint16], pattern: BayerPattern, h: int, w: int
+) -> npt.NDArray[np.uint16]:
     """3x3 window demosaic algorithm using pure numpy"""
     # Separate the components from the Bayer data to RGB planes
     rgb = np.zeros((h, w, 3), dtype=data.dtype)
@@ -204,22 +211,31 @@ def _demosaic_3x3_window(data: npt.NDArray[np.uint16], pattern: BayerPattern, h:
     borders = (window[0] - 1, window[1] - 1)
     border = (borders[0] // 2, borders[1] // 2)
 
-    rgb = np.pad(rgb, [
-        (border[0], border[0]),
-        (border[1], border[1]),
-        (0, 0),
-    ], 'constant')
-    bayer = np.pad(bayer, [
-        (border[0], border[0]),
-        (border[1], border[1]),
-        (0, 0),
-    ], 'constant')
+    rgb = np.pad(
+        rgb,
+        [
+            (border[0], border[0]),
+            (border[1], border[1]),
+            (0, 0),
+        ],
+        'constant',
+    )
+    bayer = np.pad(
+        bayer,
+        [
+            (border[0], border[0]),
+            (border[1], border[1]),
+            (0, 0),
+        ],
+        'constant',
+    )
 
     return _compute_demosaic_planes(rgb, bayer, h, w)
 
 
-def _compute_demosaic_planes(rgb: npt.NDArray[np.uint16], bayer: npt.NDArray[np.uint8],
-                             output_height: int, output_width: int) -> npt.NDArray[np.uint16]:
+def _compute_demosaic_planes(
+    rgb: npt.NDArray[np.uint16], bayer: npt.NDArray[np.uint8], output_height: int, output_width: int
+) -> npt.NDArray[np.uint16]:
     # For each plane in the RGB data, we calculate the 3x3 window sum
     # and divide it with the weighted average. This version uses direct
     # computation of the sum, instead of using numpy's as_strided()
@@ -232,32 +248,51 @@ def _compute_demosaic_planes(rgb: npt.NDArray[np.uint16], bayer: npt.NDArray[np.
         b = bayer[..., plane]
 
         # Direct computation of 3x3 window sum
-        psum = (p[:-2, :-2] + p[:-2, 1:-1] + p[:-2, 2:] +
-                p[1:-1, :-2] + p[1:-1, 1:-1] + p[1:-1, 2:] +
-                p[2:, :-2] + p[2:, 1:-1] + p[2:, 2:])
-
-        bsum = (b[:-2, :-2] + b[:-2, 1:-1] + b[:-2, 2:] +
-                b[1:-1, :-2] + b[1:-1, 1:-1] + b[1:-1, 2:] +
-                b[2:, :-2] + b[2:, 1:-1] + b[2:, 2:])
+        psum = (
+            p[:-2, :-2]
+            + p[:-2, 1:-1]
+            + p[:-2, 2:]
+            + p[1:-1, :-2]
+            + p[1:-1, 1:-1]
+            + p[1:-1, 2:]
+            + p[2:, :-2]
+            + p[2:, 1:-1]
+            + p[2:, 2:]
+        )
+
+        bsum = (
+            b[:-2, :-2]
+            + b[:-2, 1:-1]
+            + b[:-2, 2:]
+            + b[1:-1, :-2]
+            + b[1:-1, 1:-1]
+            + b[1:-1, 2:]
+            + b[2:, :-2]
+            + b[2:, 1:-1]
+            + b[2:, 2:]
+        )
 
         output[..., plane] = psum // bsum
 
     return output
 
 
-def raw_to_bgr888(data: npt.NDArray[np.uint8], width: int, height: int,
-                  bytesperline: int, fmt: PixelFormat,
-                  options: None | dict = None) -> npt.NDArray[np.uint8]:
+def raw_to_bgr888(
+    data: npt.NDArray[np.uint8],
+    width: int,
+    height: int,
+    bytesperline: int,
+    fmt: PixelFormat,
+    options: None | dict = None,
+) -> npt.NDArray[np.uint8]:
     # Parse the format
     raw_fmt = RawFormat.from_pixelformat(fmt)
 
     # Prepare the raw data into a common 16-bit format
     if raw_fmt.is_packed:
-        arr16 = prepare_packed_raw(data, width, height, raw_fmt.bits_per_pixel,
-                                   bytesperline)
+        arr16 = prepare_packed_raw(data, width, height, raw_fmt.bits_per_pixel, bytesperline)
     else:
-        arr16 = prepare_unpacked_raw(data, width, height, raw_fmt.bits_per_pixel,
-                                     bytesperline)
+        arr16 = prepare_unpacked_raw(data, width, height, raw_fmt.bits_per_pixel, bytesperline)
 
     # Perform demosaic
     rgb = demosaic(arr16, raw_fmt.bayer_pattern, options)