Spaces:
Running
Running
File size: 7,605 Bytes
3a2f49a 2619c42 3a2f49a 2619c42 3a2f49a 2619c42 3a2f49a 8507c1a 5c072a9 8507c1a 5c072a9 8507c1a 5c072a9 8507c1a 3a2f49a 2619c42 3a2f49a 2619c42 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 | """Tests for the instructor-frame filter."""
from pathlib import Path
import cv2
import numpy as np
import pytest
from PIL import Image
from app.pipeline.filter import (
_CASCADE_SPECS,
_Detector,
_load_cascades,
_load_detector,
is_instructor_frame,
filter_instructor_frames,
)
from app.pipeline.types import SceneFrame
from app.pipeline import yunet as yunet_mod
def _save(path: Path, color) -> None:
path.parent.mkdir(parents=True, exist_ok=True)
Image.new("RGB", (320, 180), color).save(path, "JPEG")
def test_load_cascades_returns_multiple_detectors():
cascades = _load_cascades()
names = {spec.name for spec, _ in cascades}
# Frontal face is the baseline; the other two are the additions that
# actually catch instructor frames in the wild.
assert "frontal" in names
assert names & {"profile", "upperbody"}, (
f"need profile or upperbody for angled-face / hands-up coverage; got {names}"
)
def test_is_instructor_frame_returns_false_on_uniform_image(tmp_path):
# A solid-color frame has no detectable face, no upper body.
p = tmp_path / "blank.jpg"
_save(p, (255, 255, 255))
assert is_instructor_frame(p, face_area_threshold=0.01) is False
def test_is_instructor_frame_handles_unreadable_path(tmp_path):
# Missing file: don't crash, treat as non-instructor.
assert is_instructor_frame(tmp_path / "does-not-exist.jpg") is False
def test_filter_keeps_blank_frames_and_unlinks_dropped(tmp_path):
# No real faces here; the filter should keep both frames and the
# filesystem should be untouched.
a = tmp_path / "a.jpg"
b = tmp_path / "b.jpg"
_save(a, (255, 255, 255))
_save(b, (10, 10, 10))
frames = [
SceneFrame(0, 0.0, 5.0, a),
SceneFrame(1, 5.0, 10.0, b),
]
kept, dropped = filter_instructor_frames(frames, face_area_threshold=0.05)
assert len(kept) == 2
assert dropped == []
assert a.exists() and b.exists()
def _force_instructor_paths(monkeypatch, instructor_paths):
"""Stub the per-frame face-area measurement so the named paths
classify as instructor (ratio above the filter's threshold) and
everyone else as clean slide content (ratio of 0).
"""
targets = {Path(p).resolve() for p in instructor_paths}
import app.pipeline.filter as filter_mod
def fake_ratio(image_path, detector=None):
return 1.0 if Path(image_path).resolve() in targets else 0.0
monkeypatch.setattr(filter_mod, "_face_area_ratio", fake_ratio)
def test_filter_drops_instructor_alternates_and_unlinks_them(tmp_path, monkeypatch):
# The picker should never offer an instructor alternate. Only the
# primary survives; the talking-head alt is removed from disk.
primary = tmp_path / "slide.jpg"
alt_bad = tmp_path / "talking_head.jpg"
alt_good = tmp_path / "slide_alt.jpg"
for p in (primary, alt_bad, alt_good):
_save(p, (200, 200, 200))
_force_instructor_paths(monkeypatch, [alt_bad])
frame = SceneFrame(0, 0.0, 5.0, primary, alt_image_paths=[alt_bad, alt_good])
kept, dropped = filter_instructor_frames([frame])
assert dropped == []
assert len(kept) == 1
assert kept[0].image_path == primary
assert kept[0].alt_image_paths == [alt_good]
assert primary.exists() and alt_good.exists()
assert not alt_bad.exists()
def test_filter_promotes_first_surviving_alt_when_primary_is_instructor(
tmp_path, monkeypatch
):
# Brightest frame happened to be a talking-head; instead of losing the
# whole segment, the first non-instructor alternate gets promoted.
primary = tmp_path / "talking_head.jpg"
alt_one = tmp_path / "slide_a.jpg"
alt_two = tmp_path / "slide_b.jpg"
for p in (primary, alt_one, alt_two):
_save(p, (200, 200, 200))
_force_instructor_paths(monkeypatch, [primary])
frame = SceneFrame(0, 0.0, 5.0, primary, alt_image_paths=[alt_one, alt_two])
kept, dropped = filter_instructor_frames([frame])
assert dropped == []
assert len(kept) == 1
assert kept[0].image_path == alt_one
assert kept[0].alt_image_paths == [alt_two]
assert not primary.exists()
assert alt_one.exists() and alt_two.exists()
def test_filter_drops_frame_only_when_every_candidate_is_instructor(
tmp_path, monkeypatch
):
primary = tmp_path / "head1.jpg"
alt = tmp_path / "head2.jpg"
for p in (primary, alt):
_save(p, (200, 200, 200))
_force_instructor_paths(monkeypatch, [primary, alt])
frame = SceneFrame(0, 0.0, 5.0, primary, alt_image_paths=[alt])
kept, dropped = filter_instructor_frames([frame])
assert kept == []
assert dropped == [frame]
assert not primary.exists() and not alt.exists()
def test_threshold_changes_drop_decision(tmp_path):
# Build a frame with a synthetic large oval the upperbody cascade is
# at least a candidate to fire on — but this is only meant to verify
# the threshold knob still gates decisions, NOT the cascade quality.
# If detection happens to miss this synthetic shape on the test box,
# the test just confirms both calls return False (consistent), which
# is still a valid invariant: same input + lower threshold ≠ more
# frames kept.
p = tmp_path / "shape.jpg"
arr = np.full((360, 640, 3), 255, dtype=np.uint8)
cv2.ellipse(arr, (320, 220), (90, 130), 0, 0, 360, (60, 60, 60), -1)
cv2.imwrite(str(p), arr)
detector = _load_detector()
strict = is_instructor_frame(p, face_area_threshold=0.001, detector=detector)
lenient = is_instructor_frame(p, face_area_threshold=0.99, detector=detector)
# Lower threshold can never be MORE permissive than higher threshold.
assert not (lenient and not strict)
def test_detector_falls_back_to_haar_when_yunet_unavailable(monkeypatch):
# Force YuNet load to fail; the filter must still build a working
# detector backed by the multi-cascade Haar setup so the pipeline
# never crashes on offline / model-missing environments.
monkeypatch.setattr(yunet_mod.YuNetDetector, "try_load", classmethod(lambda cls, **kw: None))
detector = _Detector()
assert detector.name == "haar"
assert detector.cascades is not None
# And it can still classify a blank frame without raising.
arr = np.full((100, 100, 3), 255, dtype=np.uint8)
assert detector.largest_region_area(arr) == 0
def test_yunet_detector_loads_when_model_present(tmp_path, monkeypatch):
# Skip cleanly when no model is reachable — networked CI may not have
# one, and the bundle is intentionally optional.
model = yunet_mod.resolve_model_path(allow_download=False)
if model is None:
pytest.skip("YuNet model not bundled / downloaded in this environment")
detector = yunet_mod.YuNetDetector.try_load(allow_download=False)
assert detector is not None
arr = np.full((240, 320, 3), 255, dtype=np.uint8)
assert detector.largest_face_area(arr) == 0 # blank frame, no faces
def test_yunet_resolve_skips_lfs_pointer_stubs(tmp_path, monkeypatch):
# An LFS pointer file (~130 bytes) must NOT be accepted as a real model
# — that's exactly the failure mode I hit while wiring this up.
bundled_dir = tmp_path / "models"
bundled_dir.mkdir()
pointer = bundled_dir / yunet_mod.MODEL_FILENAME
pointer.write_text(
"version https://git-lfs.github.com/spec/v1\n"
"oid sha256:0000\nsize 232589\n"
)
monkeypatch.setattr(yunet_mod, "_model_search_paths", lambda: [pointer])
assert yunet_mod.resolve_model_path(allow_download=False) is None
|