Video bilan ishlash va tezlik byudjeti

VIDEO = DATA.parent.parent / "YOLO_Tracking_Kitob" / "datasets" / "pexels" / "13921040_2560x1440.mp4"
cap = cv2.VideoCapture(str(VIDEO))
print("ochildimi:", cap.isOpened())
xossalar = {
    "FPS": cv2.CAP_PROP_FPS, "kadrlar soni": cv2.CAP_PROP_FRAME_COUNT,
    "kenglik": cv2.CAP_PROP_FRAME_WIDTH, "balandlik": cv2.CAP_PROP_FRAME_HEIGHT,
}
show(pd.DataFrame([{"xossa": n, "qiymat": round(cap.get(p), 2)} for n, p in xossalar.items()]))
fps = cap.get(cv2.CAP_PROP_FPS)
n_kadr = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
print(f"video uzunligi: {n_kadr / fps:.1f} soniya | bitta kadrga byudjet: {1000 / fps:.1f} ms")
cap.release()

cap = cv2.VideoCapture(str(VIDEO))
kadrlar = []
oqilgan = 0
while len(kadrlar) < 4:
    ok, kadr = cap.read()
    if not ok:                          # video tugadi yoki kadr buzuq
        break
    oqilgan += 1
    if oqilgan % 120 == 1:              # har 120-kadrni saqlaymiz
        kadrlar.append(cv2.resize(kadr, (480, 270)))
cap.release()
print(f"o'qilgan kadrlar: {oqilgan} | saqlangan: {len(kadrlar)}")
ko_rsat(*kadrlar, nom="video_kadrlar.png", kenglik=15,
        sarlavhalar=[f"kadr {i * 120 + 1}" for i in range(len(kadrlar))],
        izoh="Bir videodan turli vaqtdagi kadrlar. Kamera qimirlaydi, shuning uchun sahna siljiydi.")

cap = cv2.VideoCapture(str(VIDEO))
qatorlar = []
for nishon in (0, 150, 300, 600):
    cap.set(cv2.CAP_PROP_POS_FRAMES, nishon)
    ok, k = cap.read()
    haqiqiy = int(cap.get(cv2.CAP_PROP_POS_FRAMES)) - 1
    qatorlar.append({"so'ralgan kadr": nishon, "haqiqiy kadr": haqiqiy,
                     "o'qildimi": ok, "vaqt, s": round(nishon / fps, 2)})
cap.release()
show(pd.DataFrame(qatorlar))

import time
cap = cv2.VideoCapture(str(VIDEO))
cap.set(cv2.CAP_PROP_POS_FRAMES, 100)
_, katta = cap.read()
cap.release()
orta = cv2.resize(katta, (1280, 720))
kichik = cv2.resize(katta, (640, 360))

orb = cv2.ORB_create(nfeatures=1000)
amallar = {
    "resize 640x360": lambda k: cv2.resize(k, (640, 360)),
    "BGR -> kulrang": lambda k: cv2.cvtColor(k, cv2.COLOR_BGR2GRAY),
    "GaussianBlur 5x5": lambda k: cv2.GaussianBlur(k, (5, 5), 0),
    "Canny": lambda k: cv2.Canny(cv2.cvtColor(k, cv2.COLOR_BGR2GRAY), 50, 150),
    "ORB (1000 nuqta)": lambda k: orb.detectAndCompute(cv2.cvtColor(k, cv2.COLOR_BGR2GRAY), None),
    "bilateralFilter": lambda k: cv2.bilateralFilter(k, 9, 75, 75),
}

def olch(f, kadr, byudjet=0.25):
    """Amalni kamida 0.25 soniya davomida takrorlab, bitta chaqiruvning o'rtacha vaqtini beradi."""
    f(kadr)                                     # birinchi chaqiruv — "isitish", uni sanamaymiz
    n = 0
    t0 = time.perf_counter()
    while time.perf_counter() - t0 < byudjet:
        f(kadr)
        n += 1
    return (time.perf_counter() - t0) / n * 1000

qatorlar = []
for nom, f in amallar.items():
    qatorlar.append({"amal": nom,
                     "2560x1440, ms": round(olch(f, katta), 2),
                     "1280x720, ms": round(olch(f, orta), 2),
                     "640x360, ms": round(olch(f, kichik), 2)})
show(pd.DataFrame(qatorlar))
print("33.4 ms byudjetga sig'ishi kerak (29.97 FPS)")

def piksel_narxi(kadr, oqimlar):
    cv2.setNumThreads(oqimlar)
    ms = olch(lambda k: cv2.bilateralFilter(k, 9, 75, 75), kadr)
    return ms, ms * 1e6 / (kadr.shape[0] * kadr.shape[1])

qatorlar = []
for oqimlar in (0, 1):
    for nom, kadr in [("2560x1440", katta), ("1280x720", orta), ("640x360", kichik)]:
        ms, ns = piksel_narxi(kadr, oqimlar if oqimlar else cv2.getNumberOfCPUs())
        qatorlar.append({"oqimlar": cv2.getNumThreads(), "o'lcham": nom,
                         "vaqt, ms": round(ms, 2), "ns / piksel": round(ns, 1)})
cv2.setNumThreads(cv2.getNumberOfCPUs())
show(pd.DataFrame(qatorlar))

QUVUR = ("BGR -> kulrang", "GaussianBlur 5x5", "Canny", "ORB (1000 nuqta)")
qatorlar = []
for nom, kadr in [("2560x1440", katta), ("1280x720", orta), ("640x360", kichik)]:
    jami = sum(olch(amallar[a], kadr) for a in QUVUR)
    qatorlar.append({"o'lcham": nom, "piksellar": f"{kadr.shape[0] * kadr.shape[1] / 1e6:.2f} mln",
                     "quvur, ms": round(jami, 1), "mumkin bo'lgan FPS": round(1000 / jami),
                     "33.4 ms ga sig'adimi": "ha" if jami < 33.4 else "yo'q"})
show(pd.DataFrame(qatorlar))

def video_quvur(yol, n_kadr=120, kichraytir=None, ish=None):
    """Videoni o'qiydi, har kadrga `ish` ni qo'llaydi va vaqt taqsimotini qaytaradi."""
    cap = cv2.VideoCapture(str(yol))
    o_vaqt = i_vaqt = 0.0
    n = 0
    while n < n_kadr:
        t0 = time.perf_counter()
        ok, kadr = cap.read()
        t1 = time.perf_counter()
        if not ok:
            break
        if kichraytir:
            kadr = cv2.resize(kadr, kichraytir)
        if ish:
            ish(kadr)
        o_vaqt += t1 - t0
        i_vaqt += time.perf_counter() - t1
        n += 1
    cap.release()
    return n, o_vaqt * 1000 / max(n, 1), i_vaqt * 1000 / max(n, 1)

qatorlar = []
for nom, kich, ish in [
    ("faqat o'qish", None, None),
    ("o'qish + resize 640", (640, 360), None),
    ("o'qish + resize + Canny", (640, 360), lambda k: cv2.Canny(cv2.cvtColor(k, cv2.COLOR_BGR2GRAY), 50, 150)),
    ("o'qish + resize + ORB", (640, 360), lambda k: orb.detectAndCompute(cv2.cvtColor(k, cv2.COLOR_BGR2GRAY), None)),
]:
    n, o_ms, i_ms = video_quvur(VIDEO, 120, kich, ish)
    qatorlar.append({"quvur": nom, "o'qish, ms": round(o_ms, 1), "ishlov, ms": round(i_ms, 1),
                     "jami, ms": round(o_ms + i_ms, 1), "FPS": round(1000 / (o_ms + i_ms))})
show(pd.DataFrame(qatorlar))

qatorlar = []
for har in (1, 2, 3, 5):
    cap = cv2.VideoCapture(str(VIDEO))
    t0 = time.perf_counter()
    n = ishlangan = 0
    while n < 120:
        ok, kadr = cap.read()
        if not ok:
            break
        n += 1
        if n % har == 0:
            k = cv2.resize(kadr, (640, 360))
            orb.detectAndCompute(cv2.cvtColor(k, cv2.COLOR_BGR2GRAY), None)
            ishlangan += 1
    dt = time.perf_counter() - t0
    cap.release()
    qatorlar.append({"har N-kadr": har, "o'qilgan": n, "ishlangan": ishlangan,
                     "jami vaqt, s": round(dt, 2), "kadr/s": round(n / dt, 1),
                     "haqiqiy tahlil FPS": round(ishlangan / dt, 1)})
show(pd.DataFrame(qatorlar))

chiqish = DATA / "natija.mp4"
cap = cv2.VideoCapture(str(VIDEO))
fourcc = cv2.VideoWriter_fourcc(*"mp4v")
yozuvchi = cv2.VideoWriter(str(chiqish), fourcc, fps, (640, 360))
print("yozuvchi ochildimi:", yozuvchi.isOpened())
n = 0
while n < 60:
    ok, kadr = cap.read()
    if not ok:
        break
    k = cv2.resize(kadr, (640, 360))
    chekka = cv2.Canny(cv2.cvtColor(k, cv2.COLOR_BGR2GRAY), 50, 150)
    yozuvchi.write(cv2.cvtColor(chekka, cv2.COLOR_GRAY2BGR))      # yozish uchun 3 kanal kerak
    n += 1
cap.release()
yozuvchi.release()
print(f"yozilgan kadrlar: {n} | fayl hajmi: {chiqish.stat().st_size / 1024:.0f} KB")
chiqish.unlink()

cap = cv2.VideoCapture(0)                        # 0 — birinchi kamera
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)           # kamerani sozlash — dekodlashni tejaydi
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 360)
cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)              # eski kadrlar to'planib qolmasin

while True:
    ok, kadr = cap.read()
    if not ok:
        break
    cv2.imshow("kamera", kadr)
    if cv2.waitKey(1) & 0xFF == ord("q"):        # 1 ms kutadi; q bosilsa chiqadi
        break
cap.release()
cv2.destroyAllWindows()