Merge testing scripts from feauture/intergration

tests/test_cnn_eye_attention_classifier.py

@@ -0,0 +1,86 @@
+import os
+import sys
+
+import numpy as np
+import pytest
+
+PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if PROJECT_ROOT not in sys.path:
+    sys.path.insert(0, PROJECT_ROOT)
+
+
+def test_load_eye_classifier_geometric_backend():
+    from models.cnn.eye_attention.classifier import load_eye_classifier, GeometricOnlyClassifier
+
+    clf = load_eye_classifier(path="anything.pt", backend="geometric")
+    # Assert that the returned object is indeed a GeometricOnlyClassifier
+    assert isinstance(clf, GeometricOnlyClassifier)
+    assert clf.name == "geometric"
+    # Assert that it can successfully process a dummy black image and return a score
+    assert clf.predict_score([np.zeros((10, 10, 3), dtype=np.uint8)]) == 1.0
+
+
+def test_load_eye_classifier_none_path_falls_back_to_geometric(capsys):
+    from models.cnn.eye_attention.classifier import load_eye_classifier, GeometricOnlyClassifier
+    # Intentionally request the 'yolo' backend but provide no model path
+    clf = load_eye_classifier(path=None, backend="yolo")
+    assert isinstance(clf, GeometricOnlyClassifier)
+    out = capsys.readouterr().out
+    assert "falling back to geometric" in out
+
+
+def test_load_eye_classifier_extension_overrides_backend(monkeypatch, tmp_path):
+    """
+    .pth -> cnn, .pt -> yolo（但不真的加载 torch/ultralytics）
+    """
+    import models.cnn.eye_attention.classifier as m
+
+    created = {}
+    #Create dummy model classes to mock real deep learning models
+    class DummyCNN(m.EyeClassifier):
+        @property
+        def name(self) -> str:
+            return "dummy_cnn"
+
+        def predict_score(self, crops_bgr):
+            return 0.5
+
+    class DummyYOLO(m.EyeClassifier):
+        @property
+        def name(self) -> str:
+            return "dummy_yolo"
+
+        def predict_score(self, crops_bgr):
+            return 0.7
+    # Intercept the original constructors to return our dummy models
+    def fake_cnn_ctor(path, device="cpu"):
+        created["cnn"] = (path, device)
+        return DummyCNN()
+
+    def fake_yolo_ctor(path, device="cpu"):
+        created["yolo"] = (path, device)
+        return DummyYOLO()
+
+    monkeypatch.setattr(m, "EyeCNNClassifier", fake_cnn_ctor)
+    monkeypatch.setattr(m, "YOLOv11Classifier", fake_yolo_ctor)
+    #Test the '.pth' extension logic
+    pth = tmp_path / "eye_model.pth"
+    pth.write_bytes(b"not a real checkpoint")
+    clf = m.load_eye_classifier(path=str(pth), backend="yolo", device="cpu")
+    assert clf.name == "dummy_cnn"
+    assert "cnn" in created and created["cnn"][0] == str(pth)
+    #Test the '.pt' extension logic
+    pt = tmp_path / "eye_model.pt"
+    pt.write_bytes(b"not a real yolo model")
+    clf2 = m.load_eye_classifier(path=str(pt), backend="cnn", device="cpu")
+    assert clf2.name == "dummy_yolo"
+    assert "yolo" in created and created["yolo"][0] == str(pt)
+
+
+def test_load_eye_classifier_unknown_backend_raises():
+    from models.cnn.eye_attention.classifier import load_eye_classifier
+
+    with pytest.raises(ValueError):
+        # Use an unknown extension to prevent the automatic fallback mechanism
+        load_eye_classifier(path="x.unknownext", backend="unknown")
+

tests/test_cnn_eye_attention_crop.py

@@ -0,0 +1,84 @@
+import os
+import sys
+import types
+import importlib
+
+import numpy as np
+
+PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if PROJECT_ROOT not in sys.path:
+    sys.path.insert(0, PROJECT_ROOT)
+
+
+def _install_fake_facemesh_module():
+    pkg_models = sys.modules.setdefault("models", types.ModuleType("models"))
+    pkg_pretrained = sys.modules.setdefault(
+        "models.pretrained", types.ModuleType("models.pretrained")
+    )
+    pkg_face_mesh = sys.modules.setdefault(
+        "models.pretrained.face_mesh", types.ModuleType("models.pretrained.face_mesh")
+    )
+    mod = types.ModuleType("models.pretrained.face_mesh.face_mesh")
+
+    class FaceMeshDetector:
+        # get landmarks
+        LEFT_EYE_INDICES = [0, 1, 2]
+        RIGHT_EYE_INDICES = [3, 4, 5]
+
+    mod.FaceMeshDetector = FaceMeshDetector
+
+    sys.modules["models.pretrained.face_mesh.face_mesh"] = mod
+    pkg_models.pretrained = pkg_pretrained
+    pkg_pretrained.face_mesh = pkg_face_mesh
+    pkg_face_mesh.face_mesh = mod
+
+
+def test_bbox_from_landmarks_clamps_to_frame():
+    _install_fake_facemesh_module()
+    crop = importlib.import_module("models.cnn.eye_attention.crop")
+    importlib.reload(crop)
+
+    # normalize the cord
+    landmarks = np.array(
+        [
+            [0.1, 0.1, 0.0],
+            [0.2, 0.1, 0.0],
+            [0.15, 0.2, 0.0],
+            [0.8, 0.1, 0.0],
+            [0.9, 0.1, 0.0],
+            [0.85, 0.2, 0.0],
+        ],
+        dtype=np.float32,
+    )
+
+    x1, y1, x2, y2 = crop._bbox_from_landmarks(landmarks, [0, 1, 2], 100, 50, expand=0.0)
+    assert 0 <= x1 < x2 <= 100
+    assert 0 <= y1 < y2 <= 50
+
+
+def test_extract_eye_crops_returns_expected_shapes():
+    _install_fake_facemesh_module()
+    crop = importlib.import_module("models.cnn.eye_attention.crop")
+    importlib.reload(crop)
+
+    frame = np.zeros((60, 120, 3), dtype=np.uint8)
+    landmarks = np.array(
+        [
+            [0.1, 0.2, 0.0],
+            [0.2, 0.2, 0.0],
+            [0.15, 0.3, 0.0],
+            [0.7, 0.2, 0.0],
+            [0.8, 0.2, 0.0],
+            [0.75, 0.3, 0.0],
+        ],
+        dtype=np.float32,
+    )
+
+    left, right, left_bbox, right_bbox = crop.extract_eye_crops(
+        frame, landmarks, expand=0.0, crop_size=32
+    )
+    assert left.shape == (32, 32, 3)
+    assert right.shape == (32, 32, 3)
+    assert len(left_bbox) == 4
+    assert len(right_bbox) == 4
+

tests/test_pipeline_integration.py

@@ -0,0 +1,46 @@
+import os
+import sys
+
+import numpy as np
+
+PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if PROJECT_ROOT not in sys.path:
+    sys.path.insert(0, PROJECT_ROOT)
+
+from ui.pipeline import FaceMeshPipeline
+
+
+class _DummyDetector:
+    def __init__(self, landmarks=None):
+        self._landmarks = landmarks
+
+    def process(self, bgr_frame):
+        return self._landmarks
+
+    def close(self):
+        return None
+
+
+def test_face_mesh_pipeline_no_face_returns_expected_keys():
+    pipe = FaceMeshPipeline(detector=_DummyDetector(landmarks=None), eye_backend="geometric")
+    frame = np.zeros((480, 640, 3), dtype=np.uint8)
+    out = pipe.process_frame(frame)
+
+    assert isinstance(out, dict)
+    for k in ("landmarks", "s_face", "s_eye", "raw_score", "is_focused", "yaw", "pitch", "roll", "mar", "is_yawning"):
+        assert k in out
+    assert out["landmarks"] is None
+    assert 0.0 <= float(out["raw_score"]) <= 1.0
+
+
+def test_face_mesh_pipeline_with_fake_landmarks_runs():
+    fake_lm = np.zeros((478, 2), dtype=np.float32)
+    pipe = FaceMeshPipeline(detector=_DummyDetector(landmarks=fake_lm), eye_backend="geometric")
+    frame = np.zeros((480, 640, 3), dtype=np.uint8)
+    out = pipe.process_frame(frame)
+
+    assert out["landmarks"] is not None
+    assert "is_focused" in out
+    assert "raw_score" in out
+    assert 0.0 <= float(out["raw_score"]) <= 1.0
+