npm - @camstack/addon-pipeline - Versions diffs - 1.1.56 → 1.1.57 - Mend

@camstack/addon-pipeline 1.1.56 → 1.1.57

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (39) hide show

package/embed-dist/index.html CHANGED Viewed

@@ -4,7 +4,7 @@
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <title>CamStack Embed</title>
-    <script type="module" crossorigin src="./assets/index-B23riUw8.js"></script>
+    <script type="module" crossorigin src="./assets/index-DOsK8CZb.js"></script>
     <link rel="stylesheet" crossorigin href="./assets/index-Bmpl9O1K.css">
   </head>
   <body>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-pipeline",
-  "version": "1.1.56",
+  "version": "1.1.57",
   "description": "CamStack Pipeline bundle — runner, detection, motion, audio + stream broker. Multi-entry npm package shipping pipeline addons under a single bundle.",
   "keywords": [
     "camstack",
@@ -70,7 +70,8 @@
         "entry": "./dist/pipeline-runner/index.js",
         "execution": {
           "placement": "any-node",
-          "heapProfile": "heavy"
+          "heapProfile": "heavy",
+          "group": "detection"
         },
         "capabilities": [
           {
@@ -102,7 +103,8 @@
         ],
         "execution": {
           "placement": "any-node",
-          "heapProfile": "heavy"
+          "heapProfile": "heavy",
+          "group": "detection"
         },
         "protected": true,
         "icon": "assets/icon.svg",
@@ -117,7 +119,8 @@
         "entry": "./dist/motion-wasm/index.js",
         "execution": {
           "placement": "any-node",
-          "heapProfile": "heavy"
+          "heapProfile": "heavy",
+          "group": "detection"
         },
         "capabilities": [
           {
@@ -256,7 +259,6 @@
   },
   "devDependencies": {
     "@camstack/sdk": "*",
-    "@camstack/shm-ring": "*",
     "@camstack/types": "*",
     "@camstack/ui-library": "*",
     "@module-federation/vite": "^1.16.9",

package/python/inference_pool.py CHANGED Viewed

@@ -440,6 +440,27 @@ def _init_runtime(runtime: str) -> None:
     elif runtime == "onnxruntime":
         import onnxruntime as ort
         _runtime_lib = ort
+    elif runtime == "edgetpu":
+        # Coral USB Edge TPU via LiteRT (ai-edge-litert) + the libedgetpu delegate.
+        # The delegate is created ONCE here and shared across all model slots (the
+        # USB device is a single hardware context). See docs: the delegate's TF
+        # version MUST match the interpreter — feranick libedgetpu tf2.17.1 pairs
+        # with ai-edge-litert 2.1.6. Install: /data/deps/edgetpu-install.sh.
+        import threading
+        from ai_edge_litert.interpreter import Interpreter, load_delegate
+        lib_path = os.environ.get(
+            "CAMSTACK_EDGETPU_LIB", "/data/deps/edgetpu/lib/libedgetpu.so.1",
+        )
+        delegate = load_delegate(lib_path)
+        _runtime_lib = {
+            "Interpreter": Interpreter,
+            "delegate": delegate,
+            # invoke() on one interpreter is not re-entrant, and the EdgeTPU is a
+            # single-context device — serialise all predicts through one lock.
+            "lock": threading.Lock(),
+        }
+        sys.stderr.write(f"EdgeTPU: delegate loaded from {lib_path}\n")
+        sys.stderr.flush()
     else:
         raise ValueError(f"Unknown runtime: {runtime}")
@@ -679,6 +700,43 @@ def _load_model(slot: ModelSlot, config: dict) -> None:
         slot.model = session
         slot.predict_fn = predict
+    elif _runtime == "edgetpu":
+        Interpreter = _runtime_lib["Interpreter"]
+        delegate = _runtime_lib["delegate"]
+        lock = _runtime_lib["lock"]
+        interp = Interpreter(path, experimental_delegates=[delegate])
+        interp.allocate_tensors()
+        in_det = interp.get_input_details()[0]
+        out_dets = interp.get_output_details()
+        _, in_h, in_w, _ = (int(x) for x in in_det["shape"])
+        in_dtype = np.dtype(in_det["dtype"]).name  # 'uint8' | 'int8' | 'float32'
+        slot.config["_input_name"] = in_det["name"]
+        slot.config["_edgetpu_in_dtype"] = in_dtype
+        slot.config["inputWidth"] = in_w
+        slot.config["inputHeight"] = in_h
+        slot.config.setdefault("inputSize", max(in_w, in_h))
+        in_index = int(in_det["index"])
+        out_index = [int(o["index"]) for o in out_dets]
+        sys.stderr.write(
+            f"EdgeTPU: loaded {os.path.basename(path)} in={in_w}x{in_h} "
+            f"dtype={in_dtype} outputs={len(out_dets)}\n"
+        )
+        sys.stderr.flush()
+        def predict(
+            inp_dict: dict,
+            _interp=interp, _lock=lock, _in=in_index, _outs=out_index,
+        ) -> dict:
+            tensor = next(iter(inp_dict.values()))
+            with _lock:
+                _interp.set_tensor(_in, tensor)
+                _interp.invoke()
+                # Positional keys — the ssd postprocessor reads "0".."3".
+                return {str(i): _interp.get_tensor(idx) for i, idx in enumerate(_outs)}
+        slot.model = interp
+        slot.predict_fn = predict
     slot.loaded = True
@@ -732,8 +790,68 @@ def _is_channels_last(input_shape) -> bool:
     return last in (1, 3) and second is not None and second not in (1, 3)
+def _resolve_input_dims(config: dict) -> tuple[int, int, int]:
+    """Resolve (width, height, channels) for the model input.
+    Explicit `inputWidth`/`inputHeight` (threaded from the catalog's
+    `inputSize.{width,height}`) win; they fall back to the square `inputSize`
+    (the max side) for legacy square models. `inputChannels` defaults to 3
+    (RGB); 1 selects the grayscale CTC recognizer path. Pure — no numpy/PIL.
+    """
+    input_size = int(config.get("inputSize", 640))
+    width = int(config.get("inputWidth") or input_size)
+    height = int(config.get("inputHeight") or input_size)
+    channels = int(config.get("inputChannels") or 3)
+    return width, height, channels
+def _to_model_tensor(arr: "np.ndarray", channels_last: bool) -> "np.ndarray":
+    """Build the batched RGB model-input tensor from an HWC float array in [0,1].
+    - ``channels_last`` (ArcFace/CLIP NHWC) → ``[1,H,W,C]`` untransposed.
+    - otherwise → standard detector NCHW ``[1,C,H,W]``.
+    Grayscale CTC recognizers do NOT use this — they need aspect-preserving
+    resize + edge padding, see {@link _preprocess_ctc_gray}. Pure numpy.
+    """
+    if channels_last:
+        return arr[np.newaxis].astype(np.float32)
+    return arr.transpose(2, 0, 1)[np.newaxis].astype(np.float32)
+def _preprocess_ctc_gray(img: "Image.Image", input_w: int, input_h: int) -> "np.ndarray":
+    """EasyOCR-accurate preprocess for a fixed-width grayscale CTC recognizer.
+    Mirrors EasyOCR's AlignCollate + NormalizePAD exactly:
+      1. grayscale by luminance (PIL ``convert('L')``),
+      2. resize to height ``input_h`` PRESERVING aspect ratio (width capped at
+         ``input_w``) with BICUBIC — the recognizer was trained on undistorted
+         glyphs; stretching the crop to the full ``input_w`` warps glyph aspect
+         ~4x and the model reads noise (low-confidence garbage),
+      3. normalize to ``[-1,1]`` (``(x/255 - 0.5)/0.5``),
+      4. right-pad the width up to ``input_w`` by replicating the last column
+         (EasyOCR NormalizePAD edge padding — NOT zeros).
+    Returns a ``[1,1,input_h,input_w]`` float32 tensor. Pure numpy/PIL.
+    """
+    gray = img.convert("L")
+    ow, oh = gray.size
+    ratio = (ow / oh) if oh > 0 else 1.0
+    resized_w = int(np.ceil(input_h * ratio))
+    resized_w = max(1, min(input_w, resized_w))
+    gray = gray.resize((resized_w, input_h), Image.BICUBIC)
+    arr = np.asarray(gray, dtype=np.float32) / 255.0  # (H, resized_w)
+    arr = (arr - 0.5) / 0.5  # [-1, 1]
+    if resized_w < input_w:
+        edge = arr[:, resized_w - 1 : resized_w]
+        pad = np.repeat(edge, input_w - resized_w, axis=1)
+        arr = np.concatenate([arr, pad], axis=1)
+    return arr[np.newaxis, np.newaxis].astype(np.float32)  # (1, 1, H, W)
 def _preprocess(img: Image.Image, config: dict) -> tuple[dict, float, tuple[int, int]]:
     input_size = config.get("inputSize", 640)
+    input_w, input_h, input_channels = _resolve_input_dims(config)
     # Bench frames have _bench_frame_id tag → use preprocess cache
     bench_fid = getattr(img, '_bench_frame_id', None)
     if bench_fid is not None:
@@ -764,23 +882,22 @@ def _preprocess(img: Image.Image, config: dict) -> tuple[dict, float, tuple[int,
             input_dict[input_name] = canvas
             arr = None  # not used downstream for imageType — postprocess runs on predictions
         elif input_shape is not None and len(input_shape) == 4:
-            if preprocess_mode == "letterbox":
-                arr, scale_val, pad = letterbox(img, input_size)
-            else:
-                arr = resize_image(img, input_size, input_size)
+            if input_channels == 1:
+                # Grayscale CTC recognizer — EasyOCR aspect-preserving preprocess.
+                input_arr = _preprocess_ctc_gray(img, input_w, input_h)
                 scale_val = 1.0
                 pad = (0, 0)
-            _, _, _, w_or_c = input_shape
-            if w_or_c in (1, 3):
-                input_arr = arr[np.newaxis].astype(np.float32)
             else:
-                input_arr = arr.transpose(2, 0, 1)[np.newaxis].astype(np.float32)
-            if input_shape[1] == 1 and input_shape[2] != input_shape[3]:
-                gray = np.mean(arr, axis=2)
-                target_h, target_w = input_shape[2], input_shape[3]
-                gray_img = Image.fromarray((gray * 255).astype(np.uint8), mode="L")
-                gray_img = gray_img.resize((target_w, target_h), Image.BILINEAR)
-                input_arr = np.array(gray_img, dtype=np.float32)[np.newaxis, np.newaxis] / 255.0
+                if preprocess_mode == "letterbox":
+                    arr, scale_val, pad = letterbox(img, input_size)
+                else:
+                    arr = resize_image(img, input_w, input_h)
+                    scale_val = 1.0
+                    pad = (0, 0)
+                # NHWC vs NCHW from the model's declared last dim (1/3 ⇒
+                # channels-last), exactly as before for 3-channel models.
+                _, _, _, w_or_c = input_shape
+                input_arr = _to_model_tensor(arr, w_or_c in (1, 3))
             input_dict[input_name] = input_arr
         else:
             input_arr = arr.transpose(2, 0, 1)[np.newaxis].astype(np.float32)
@@ -791,25 +908,52 @@ def _preprocess(img: Image.Image, config: dict) -> tuple[dict, float, tuple[int,
             input_dict["iouThreshold"] = 0.45
         if "confidenceThreshold" in input_names:
             input_dict["confidenceThreshold"] = config.get("confidence", 0.25)
-    else:
-        # OpenVINO / ONNX — always need float CHW tensor.
+    elif _runtime == "edgetpu":
+        # EdgeTPU models are FULL-INTEGER quantized: feed raw uint8 (or int8)
+        # pixels in NHWC [1,H,W,C] — NO float /255 normalization (that is baked
+        # into the model's quantization params).
+        input_name = config.get("_input_name", "images")
+        in_w = int(config.get("inputWidth") or config.get("inputSize", 300))
+        in_h = int(config.get("inputHeight") or config.get("inputSize", 300))
         if preprocess_mode == "letterbox":
-            arr, scale_val, pad = letterbox(img, input_size)
+            canvas, scale_val, pad = letterbox_image(img, max(in_w, in_h))
+            rgb = canvas
+        else:
+            rgb = img if img.size == (in_w, in_h) else img.resize((in_w, in_h), Image.BILINEAR)
+            scale_val, pad = 1.0, (0, 0)
+        pix = np.asarray(rgb, dtype=np.uint8)
+        if pix.ndim == 2:
+            pix = np.stack([pix] * 3, axis=-1)
+        if config.get("_edgetpu_in_dtype") == "int8":
+            input_dict[input_name] = (pix.astype(np.int16) - 128).astype(np.int8)[np.newaxis]
         else:
-            arr = resize_image(img, input_size, input_size)
+            input_dict[input_name] = pix[np.newaxis]  # uint8 NHWC
+    else:
+        # OpenVINO / ONNX — always need a float tensor.
+        input_name = config.get("_input_name", "images")
+        if input_channels == 1:
+            # Grayscale CTC recognizer (EasyOCR plate-OCR): aspect-preserving
+            # resize + edge-pad + [-1,1] norm → [1,1,H,W]. NOT the squared
+            # 3-channel RGB tensor (which the runtime rejected — the reason
+            # plate recognition never ran).
+            input_dict[input_name] = _preprocess_ctc_gray(img, input_w, input_h)
             scale_val = 1.0
             pad = (0, 0)
-        input_name = config.get("_input_name", "images")
-        # Feed the layout the model actually declares. NHWC models (ArcFace
-        # face-embedding [N,112,112,3], CLIP) must NOT be NCHW-transposed —
-        # a strict backend (NPU) throws on the wrong shape and the embedding
-        # is never produced (the multi-day face-collection outage). Unknown
-        # shape → NCHW (the prior behaviour), so detectors are unaffected.
-        if _is_channels_last(config.get("_input_shape")):
-            input_arr = arr[np.newaxis].astype(np.float32)
         else:
-            input_arr = arr.transpose(2, 0, 1)[np.newaxis].astype(np.float32)
-        input_dict[input_name] = input_arr
+            if preprocess_mode == "letterbox":
+                arr, scale_val, pad = letterbox(img, input_size)
+            else:
+                arr = resize_image(img, input_w, input_h)
+                scale_val = 1.0
+                pad = (0, 0)
+            # Feed the layout the model actually declares. NHWC models (ArcFace
+            # face-embedding [N,112,112,3], CLIP) must NOT be NCHW-transposed —
+            # a strict backend (NPU) throws on the wrong shape and the embedding
+            # is never produced (the multi-day face-collection outage). Unknown
+            # shape → NCHW (the prior behaviour), so detectors are unaffected.
+            input_dict[input_name] = _to_model_tensor(
+                arr, _is_channels_last(config.get("_input_shape"))
+            )
     result = (input_dict, scale_val, pad)
     if bench_fid is not None:

package/python/postprocessors/__init__.py CHANGED Viewed

@@ -12,6 +12,7 @@ from .softmax import postprocess_softmax
 from .ctc import postprocess_ctc
 from .saliency import postprocess_saliency
 from .yamnet import postprocess_yamnet
+from .ssd import postprocess_ssd
 POSTPROCESSORS = {
     "yolo": postprocess_yolo,
@@ -23,4 +24,5 @@ POSTPROCESSORS = {
     "ctc": postprocess_ctc,
     "saliency": postprocess_saliency,
     "yamnet": postprocess_yamnet,
+    "ssd": postprocess_ssd,
 }

package/python/postprocessors/ssd.py ADDED Viewed

@@ -0,0 +1,128 @@
+"""SSD / EfficientDet-Lite postprocessor (TFLite_Detection_PostProcess op).
+Used by the EdgeTPU (Coral USB Edge TPU) runtime with the Coral model-zoo
+SSD MobileNet V2 and EfficientDet-Lite detectors. Those models embed the
+``TFLite_Detection_PostProcess`` op, so the 4 output tensors are ALREADY
+decoded (boxes + per-box class + score, post-NMS):
+    output 0  boxes    [1, N, 4]  (ymin, xmin, ymax, xmax) normalised 0..1
+    output 1  classes  [1, N]     float class indices (COCO 90-class map)
+    output 2  scores   [1, N]     float 0..1
+    output 3  count    [1]        number of valid detections
+The inference_pool ``edgetpu`` predict closure returns them keyed by their
+positional output index ("0".."3"). Output matches the yolo postprocessor:
+``{"kind": "detections", "detections": [{"class", "score", "bbox":[x1,y1,x2,y2]}]}``
+with pixel bboxes in ORIGINAL frame coordinates.
+"""
+from __future__ import annotations
+import numpy as np
+# Coral COCO 90-class label map (github.com/google-coral/test_data coco_labels.txt).
+# The "n/a" placeholders keep the raw model class indices aligned and are skipped.
+COCO_90 = [
+    "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck",
+    "boat", "traffic light", "fire hydrant", "n/a", "stop sign", "parking meter",
+    "bench", "bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear",
+    "zebra", "giraffe", "n/a", "backpack", "umbrella", "n/a", "n/a", "handbag",
+    "tie", "suitcase", "frisbee", "skis", "snowboard", "sports ball", "kite",
+    "baseball bat", "baseball glove", "skateboard", "surfboard", "tennis racket",
+    "bottle", "n/a", "wine glass", "cup", "fork", "knife", "spoon", "bowl",
+    "banana", "apple", "sandwich", "orange", "broccoli", "carrot", "hot dog",
+    "pizza", "donut", "cake", "chair", "couch", "potted plant", "bed", "n/a",
+    "dining table", "n/a", "n/a", "toilet", "n/a", "tv", "laptop", "mouse",
+    "remote", "keyboard", "cell phone", "microwave", "oven", "toaster", "sink",
+    "refrigerator", "n/a", "book", "clock", "vase", "scissors", "teddy bear",
+    "hair drier", "toothbrush",
+]
+def _split_outputs(predictions: dict) -> tuple:
+    """Resolve (boxes, classes, scores, count) from the raw prediction dict.
+    Primary path: positional keys "0".."3" (the edgetpu predict closure).
+    Fallback: shape-based identification for name-keyed / reordered exports.
+    """
+    if all(k in predictions for k in ("0", "1", "2", "3")):
+        return (
+            np.asarray(predictions["0"]),
+            np.asarray(predictions["1"]),
+            np.asarray(predictions["2"]),
+            np.asarray(predictions["3"]),
+        )
+    vals = [np.asarray(v) for v in predictions.values()]
+    boxes = count = None
+    two_d: list[np.ndarray] = []
+    for v in vals:
+        if v.ndim >= 2 and v.shape[-1] == 4:
+            boxes = v
+        elif v.ndim == 1 or (v.ndim == 2 and v.shape[-1] == 1):
+            count = v
+        elif v.ndim == 2:
+            two_d.append(v)
+    # TFLite_Detection_PostProcess emits classes BEFORE scores.
+    classes = two_d[0] if len(two_d) > 0 else None
+    scores = two_d[1] if len(two_d) > 1 else None
+    return boxes, classes, scores, count
+def postprocess_ssd(
+    predictions: dict,
+    config: dict,
+    orig_w: int,
+    orig_h: int,
+    scale: float,
+    pad: tuple,
+) -> dict:
+    """Decode SSD/EfficientDet postprocess outputs to original-frame detections."""
+    conf_threshold = float(config.get("confidence", 0.4) or 0.4)
+    input_size = int(config.get("inputSize", 300) or 300)
+    boxes, classes, scores, count = _split_outputs(predictions)
+    if boxes is None or scores is None:
+        return {"kind": "detections", "detections": []}
+    boxes = boxes.reshape(-1, 4)
+    scores = scores.reshape(-1)
+    classes = classes.reshape(-1) if classes is not None else np.zeros_like(scores)
+    n = len(scores)
+    if count is not None and count.size:
+        n = min(n, int(count.reshape(-1)[0]))
+    n = min(n, len(boxes), len(classes))
+    pad_x, pad_y = pad
+    is_letterbox = not (abs(scale - 1.0) < 1e-6 and pad_x == 0 and pad_y == 0)
+    detections = []
+    for i in range(n):
+        score = float(scores[i])
+        if score < conf_threshold:
+            continue
+        ymin, xmin, ymax, xmax = (float(v) for v in boxes[i])
+        if is_letterbox:
+            # Invert letterbox: normalised -> input px -> remove pad -> unscale.
+            x1 = (xmin * input_size - pad_x) / scale
+            y1 = (ymin * input_size - pad_y) / scale
+            x2 = (xmax * input_size - pad_x) / scale
+            y2 = (ymax * input_size - pad_y) / scale
+        else:
+            # Plain resize: normalised coords map linearly to the original frame.
+            x1, y1, x2, y2 = xmin * orig_w, ymin * orig_h, xmax * orig_w, ymax * orig_h
+        x1 = max(0.0, min(x1, orig_w))
+        x2 = max(0.0, min(x2, orig_w))
+        y1 = max(0.0, min(y1, orig_h))
+        y2 = max(0.0, min(y2, orig_h))
+        if x2 <= x1 or y2 <= y1:
+            continue
+        cls = int(classes[i])
+        label = COCO_90[cls] if 0 <= cls < len(COCO_90) else str(cls)
+        if label == "n/a":
+            continue
+        detections.append({
+            "class": label,
+            "score": round(score, 4),
+            "bbox": [round(x1, 1), round(y1, 1), round(x2, 1), round(y2, 1)],
+        })
+    return {"kind": "detections", "detections": detections}

package/python/requirements-edgetpu.txt ADDED Viewed

@@ -0,0 +1,23 @@
+# EdgeTPU (Coral USB Edge TPU) backend.
+#
+# Interpreter: ai-edge-litert (LiteRT) — numpy-2 native, cp39-cp312 wheels.
+# We use LiteRT (NOT tflite-runtime / pycoral) because:
+#   * pycoral official wheels cap at Python 3.9; the hub venv is 3.12.
+#   * feranick's tflite-runtime cp312 wheel is compiled against numpy 1.x and
+#     crashes under the hub's numpy 2.x (OpenVINO needs numpy<2.4).
+#   * ai-edge-litert exposes tflite_runtime-compatible Interpreter + load_delegate
+#     and is numpy-2 native.
+ai-edge-litert==2.1.6
+# libedgetpu.so.1 (the Coral delegate) is a SYSTEM shared library — pip cannot
+# install it. It MUST be provided out-of-band and its TensorFlow version MUST
+# match the interpreter (stock Coral libedgetpu 16.0/grouper is built against old
+# TFLite and FAILS at invoke: "EdgeTpuDelegateForCustomOp failed to invoke").
+# The hub uses feranick's libedgetpu rebuilt against TF 2.17.1 (std/throttled),
+# installed under /data/deps/edgetpu/lib/libedgetpu.so.1 by the persistent
+# installer /data/deps/edgetpu-install.sh. The path is overridable via the
+# CAMSTACK_EDGETPU_LIB env var (default /data/deps/edgetpu/lib/libedgetpu.so.1).
+#
+# Host prerequisite: the container must have /dev/bus/usb passed through plus a
+# `--device-cgroup-rule 'c 189:* rmw'` rule (the Coral re-enumerates its USB
+# minor after firmware init, so a fixed --device does not survive).

package/python/test_inference_pool_layout.py CHANGED Viewed

@@ -18,7 +18,22 @@ for _mod in ("numpy", "PIL", "PIL.Image"):
 if not hasattr(sys.modules["PIL"], "Image"):
     sys.modules["PIL"].Image = types.ModuleType("PIL.Image")
-from inference_pool import _is_channels_last  # noqa: E402
+from inference_pool import _is_channels_last, _resolve_input_dims  # noqa: E402
+def test_resolve_input_dims_defaults_to_square_rgb() -> None:
+    # Legacy square model: no explicit width/height/channels → (size, size, 3).
+    assert _resolve_input_dims({"inputSize": 640}) == (640, 640, 3)
+def test_resolve_input_dims_explicit_non_square_grayscale() -> None:
+    # Plate-OCR VGG: 384×64, 1 channel — the shape the OCR runtime demands.
+    cfg = {"inputSize": 384, "inputWidth": 384, "inputHeight": 64, "inputChannels": 1}
+    assert _resolve_input_dims(cfg) == (384, 64, 1)
+def test_resolve_input_dims_falls_back_to_size_when_dims_missing() -> None:
+    assert _resolve_input_dims({"inputSize": 320}) == (320, 320, 3)
 def test_arcface_nhwc_is_channels_last() -> None:

package/python/test_inference_pool_preprocess.py ADDED Viewed

@@ -0,0 +1,65 @@
+"""Numeric tests for the preprocess tensor builders — `_to_model_tensor`
+(RGB NHWC/NCHW) and `_preprocess_ctc_gray` (EasyOCR grayscale plate-OCR).
+Requires real numpy + PIL (the embedded portable Python the pool runs on). On a
+minimal sandbox without them the whole module is skipped — the pure branch-
+selection logic is covered separately in `test_inference_pool_layout.py`.
+"""
+import pytest
+np = pytest.importorskip("numpy")
+PIL = pytest.importorskip("PIL")
+from PIL import Image  # noqa: E402
+from inference_pool import _to_model_tensor, _preprocess_ctc_gray  # noqa: E402
+def _hwc(h: int, w: int) -> "np.ndarray":
+    return (np.arange(h * w * 3, dtype=np.float32) % 255 / 255.0).reshape(h, w, 3)
+def test_rgb_detector_is_nchw() -> None:
+    out = _to_model_tensor(_hwc(640, 640), channels_last=False)
+    assert out.shape == (1, 3, 640, 640)
+    assert out.dtype == np.float32
+def test_rgb_embedder_is_nhwc_when_channels_last() -> None:
+    # ArcFace/CLIP: keep [1,H,W,C] — never transpose.
+    out = _to_model_tensor(_hwc(112, 112), channels_last=True)
+    assert out.shape == (1, 112, 112, 3)
+def test_ctc_gray_shape_is_nchw_single_channel() -> None:
+    # Plate-OCR: model input [1, 1, 64, 384].
+    img = Image.new("RGB", (200, 60), (128, 128, 128))
+    out = _preprocess_ctc_gray(img, input_w=384, input_h=64)
+    assert out.shape == (1, 1, 64, 384)
+    assert out.dtype == np.float32
+def test_ctc_gray_is_normalized_to_minus_one_one() -> None:
+    # A flat mid-gray (128) maps to ~0 under (x/255-0.5)/0.5.
+    img = Image.new("RGB", (200, 60), (128, 128, 128))
+    out = _preprocess_ctc_gray(img, 384, 64)
+    assert abs(float(out.mean())) < 0.02
+    white = _preprocess_ctc_gray(Image.new("RGB", (200, 60), (255, 255, 255)), 384, 64)
+    black = _preprocess_ctc_gray(Image.new("RGB", (200, 60), (0, 0, 0)), 384, 64)
+    assert np.allclose(white, 1.0, atol=1e-3)
+    assert np.allclose(black, -1.0, atol=1e-3)
+def test_ctc_gray_preserves_aspect_and_edge_pads() -> None:
+    # A 128 wide × 64 tall crop → ratio 2.0 → resized_w = ceil(64*2)=128 ≤ 384,
+    # so the right 384-128=256 columns are edge-replicated (equal to col 127).
+    img = Image.new("RGB", (128, 64), (200, 200, 200))
+    out = _preprocess_ctc_gray(img, 384, 64)[0, 0]  # (64, 384)
+    # Padded region replicates the last real column → constant across width here.
+    assert np.allclose(out[:, 128:], out[:, 127:128], atol=1e-4)
+def test_ctc_gray_caps_resized_width_at_input_w() -> None:
+    # Very wide crop (ratio > 6) → resized_w capped at input_w (no overflow).
+    img = Image.new("RGB", (800, 64), (50, 50, 50))
+    out = _preprocess_ctc_gray(img, 384, 64)
+    assert out.shape == (1, 1, 64, 384)