실습 5 — 프레임당 처리 시간과 FPS 재기

import time
import cv2
import numpy as np
import matplotlib.pyplot as plt

plt.rcParams["font.family"] = "Malgun Gothic"
plt.rcParams["axes.unicode_minus"] = False

# 읽는 시간이 섞이지 않게 프레임을 먼저 모두 읽어 둔다
cap = cv2.VideoCapture("ch15_conveyor.mp4")
frames = []
while True:
    ok, frame = cap.read()
    if not ok:
        break
    frames.append(frame)
cap.release()

def process(frame, size=None):
    """(크기를 줄이고) Bilateral 필터 → 흑백 → Canny 를 건다."""
    if size is not None:
        frame = cv2.resize(frame, size)                  # size = (가로, 세로)
    smooth = cv2.bilateralFilter(frame, 15, 75, 75)      # 7차시: 경계를 지키는 무거운 필터
    gray = cv2.cvtColor(smooth, cv2.COLOR_BGR2GRAY)
    return cv2.Canny(gray, 50, 150)

print("준비한 프레임:", len(frames), "장 · 원래 크기:", frames[0].shape)
print("절반 크기의 결과 모양:", process(frames[0], (160, 120)).shape)

def measure(size=None):
    """프레임마다 처리 시간(ms)을 재어 목록으로 돌려준다."""
    times = []
    for frame in frames:
        start = time.perf_counter()                       # 처리 직전 시각(초)
        process(frame, size)
        times.append((time.perf_counter() - start) * 1000)   # 걸린 시간을 ms 로
    return times

full = measure()
full_avg = sum(full) / len(full)
print(f"원래 크기 320×240: 한 장 평균 {full_avg:.1f}ms → 1초에 {1000 / full_avg:.1f}장 처리 가능")
for fps in (10, 30):
    budget = 1000 / fps                                   # 프레임 간격(ms)
    verdict = "제때 끝남" if full_avg <= budget else "늦음"
    print(f"  {fps}fps 의 프레임 간격 {budget:.1f}ms → {verdict}")

half = measure((160, 120))
half_avg = sum(half) / len(half)
print(f"절반 크기 160×120: 한 장 평균 {half_avg:.1f}ms → 1초에 {1000 / half_avg:.1f}장 처리 가능")
for fps in (10, 30):
    budget = 1000 / fps
    verdict = "제때 끝남" if half_avg <= budget else "늦음"
    print(f"  {fps}fps 의 프레임 간격 {budget:.1f}ms → {verdict}")
# 칸 수는 4분의 1 로 줄었다. 시간은 몇 배 줄었는지 본다
print(f"칸 수: {320 * 240:,} → {160 * 120:,} (4분의 1)")
print(f"빨라진 정도: {full_avg / half_avg:.1f}배")

def simulate(times, fps):
    """프레임이 1000/fps ms 마다 들어올 때, 처리 중에 온 프레임은 건너뛴다고 보고 센다."""
    gap = 1000 / fps
    busy_until, done, skipped = 0.0, 0, 0
    for i, t in enumerate(times):
        arrive = i * gap                     # i 번 프레임이 들어오는 시각(ms)
        if arrive < busy_until:              # 앞 프레임을 아직 처리하는 중이면 건너뛴다
            skipped += 1
            continue
        busy_until = arrive + t              # 이 프레임의 처리가 끝나는 시각
        done += 1
    return done, skipped

rows = []
for name, times in (("원래 크기", full), ("절반 크기", half)):
    for fps in (10, 30):
        done, skipped = simulate(times, fps)
        rows.append((name, fps, done, skipped))
        print(f"{name} · {fps}fps: {len(times)}장 가운데 처리 {done}장, 건너뜀 {skipped}장")

fig, ax = plt.subplots(figsize=(7, 3.4))
ax.bar(["원래 크기\n320×240", "절반 크기\n160×120"], [full_avg, half_avg])
ax.axhline(100, linestyle="--", color="gray")
ax.axhline(1000 / 30, linestyle=":", color="gray")
ax.text(1.45, 100, "10fps 간격 100ms", va="bottom", ha="right")
ax.text(1.45, 1000 / 30, "30fps 간격 33.3ms", va="bottom", ha="right")
ax.set_ylabel("한 장 평균 처리 시간 (ms)")
ax.set_ylim(0, 115)
ax.set_title("크기에 따른 프레임 하나의 처리 시간")
plt.tight_layout()
plt.show()