Sub-15ms Optical State Verification on Commodity Hardware.

"""
live_inference.py — Real-time optical state inspector for DesktopQualityInspector.
Captures live frames via cv2.CAP_DSHOW, executes YOLO11 nano inference, and overlays
color-coded bounding boxes and state classifications.
"""
import argparse
import time
from pathlib import Path
import cv2
from ultralytics import YOLO

from config import CLASS_COLORS, DEFAULT_CONFIDENCE, DEFAULT_MODEL_PATH, DEFAULT_SOURCE

def open_camera(source: str) -> cv2.VideoCapture:
    """Open video source. Accepts device index (e.g. 0, 1) or IP stream URL."""
    cam_source = int(source) if source.isdigit() else source

    # cv2.CAP_DSHOW explicitly bypasses MSMF virtual camera blackouts on Windows
    if isinstance(cam_source, int):
        cap = cv2.VideoCapture(cam_source, cv2.CAP_DSHOW)
    else:
        cap = cv2.VideoCapture(cam_source)

    if not cap.isOpened():
        raise RuntimeError(f"Could not open video source '{source}'.")
    return cap

def main():
    args = parse_args()
    model = YOLO(args.model)
    cap = open_camera(args.source)
    
    prev_time = time.time()
    try:
        while True:
            ret, frame = cap.read()
            if not ret:
                break

            # Execute forward pass with confidence filter and custom input resolution
            results = model.predict(source=frame, conf=args.conf, imgsz=args.imgsz, verbose=False)
            
            # Calculate instantaneous frame rate
            curr_time = time.time()
            fps = 1.0 / (curr_time - prev_time)
            prev_time = curr_time

            # Draw high-contrast bounding boxes & labels per detection
            for r in results:
                for box in r.boxes:
                    cls_id = int(box.cls[0])
                    class_name = model.names[cls_id]
                    confidence = float(box.conf[0])
                    color = CLASS_COLORS.get(class_name, (255, 255, 255))
                    
                    x1, y1, x2, y2 = map(int, box.xyxy[0])
                    cv2.rectangle(frame, (x1, y1), (x2, y2), color, thickness=2)
                    label = f"{class_name.upper()} {confidence:.2f}"
                    cv2.putText(frame, label, (x1, max(y1 - 8, 15)), 
                                cv2.FONT_HERSHEY_SIMPLEX, 0.6, color, 2)

            cv2.imshow("DesktopQualityInspector — Live Feed", frame)
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
    finally:
        cap.release()
        cv2.destroyAllWindows()

if __name__ == "__main__":
    main()

"""
config.py — Centralized parameters for DesktopQualityInspector.
Decouples threshold parameters and color palettes so any 2-class or multi-class
model can be dropped in without changing inference loop logic.
"""
# Path to the fine-tuned YOLO weights checkpoint produced in Colab
DEFAULT_MODEL_PATH = "models/best.pt"

# Camera index: 0 is built-in webcam; 1, 2 or 3 is usually DroidCam
DEFAULT_SOURCE = 0

# Minimum confidence score (0.0 - 1.0) required to draw detection box
DEFAULT_CONFIDENCE = 0.50

# Class color mapping (BGR format for OpenCV).
# Keys must correspond identically with Roboflow export classes:
CLASS_COLORS = {
    "lever_open": (34, 197, 94),     # Emerald Green in BGR
    "lever_closed": (46, 57, 239),   # Crimson Red in BGR
}

"""
scripts/list_cameras.py — Camera index enumerator with DirectShow preview.
Scans system video handles 0..9 and renders live previews with index overlays
to identify DroidCam wireless feeds without device manager guesswork.
"""
import cv2

def scan_cameras(max_tested: int = 6):
    print("[SCAN] Probing video indices using DirectShow (CAP_DSHOW)...")
    available_indices = []
    
    for idx in range(max_tested):
        cap = cv2.VideoCapture(idx, cv2.CAP_DSHOW)
        if cap.isOpened():
            ret, frame = cap.read()
            if ret:
                print(f" -> Index {idx}: ONLINE (Resolution: {frame.shape[1]}x{frame.shape[0]})")
                available_indices.append(idx)
                # Display test window for visual identification
                cv2.putText(frame, f"CAMERA INDEX: {idx} [PRESS SPACE/Q]", (30, 40),
                            cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 240, 255), 2)
                cv2.imshow(f"Camera Scanner — Index {idx}", frame)
                key = cv2.waitKey(0) & 0xFF
                cv2.destroyWindow(f"Camera Scanner — Index {idx}")
                if key == ord('q'):
                    break
            cap.release()
            
    print(f"[RESULT] Detected usable cameras: {available_indices}")

if __name__ == "__main__":
    scan_cameras()

# notebooks/train_colab.py — Google Colab T4 GPU Fine-Tuning Recipe
# Install Ultralytics and Roboflow SDK in Colab session:
!pip install ultralytics roboflow

from roboflow import Roboflow
from ultralytics import YOLO

# 1. Download your versioned dataset from Roboflow (transient API key, not in git):
rf = Roboflow(api_key="YOUR_ROBOFLOW_API_KEY")
project = rf.workspace("mirconegri").project("desktop-quality-inspector")
version = project.version(1)
dataset = version.download("yolo11")

# 2. Transfer-learn from lightweight YOLO11n checkpoint on Colab free T4 GPU:
model = YOLO("yolo11n.pt")

results = model.train(
    data=f"{dataset.location}/data.yaml",
    epochs=80,
    imgsz=640,
    batch=16,
    patience=15,           # Early stopping if no mAP improvement in 15 epochs
    name="lever-detector",
    device=0               # CUDA device 0 (Colab T4)
)

# 3. Validate against held-out validation split:
metrics = model.val()
print(f"Validation mAP@50: {metrics.box.map50:.4f}")

# 4. Download best.pt artifact to place in local models/ directory:
from google.colab import files
files.download("runs/detect/lever-detector/weights/best.pt")