Harakatni aniqlash va obyektni kuzatish

VIDEO = DATA / "harakat.mp4"
haqiqat = pd.read_csv(DATA / "harakat_haqiqat.csv")
print(f"kadrlar: {len(haqiqat)}")
show(haqiqat.head(4))

cap = cv2.VideoCapture(str(VIDEO))
kadrlar = []
for i in range(150):
    ok, k = cap.read()
    if not ok:
        break
    if i in (0, 60, 120):
        kadrlar.append(k)
cap.release()
ko_rsat(*kadrlar, nom="harakat_kadrlar.png", kenglik=15,
        sarlavhalar=["kadr 0", "kadr 60", "kadr 120"],
        izoh="Fon qimirlamaydi, ikki obyekt harakatlanadi: qizil to'rtburchak o'ngga, yashil doira chapga.")

cap = cv2.VideoCapture(str(VIDEO))
_, a = cap.read()
for _ in range(4):
    ok, b = cap.read()
cap.release()
ga = cv2.cvtColor(a, cv2.COLOR_BGR2GRAY)
gb = cv2.cvtColor(b, cv2.COLOR_BGR2GRAY)
farq = cv2.absdiff(ga, gb)
_, maska = cv2.threshold(farq, 25, 255, cv2.THRESH_BINARY)
print(f"farq: o'rtacha {farq.mean():.2f}, maksimum {farq.max()} | "
      f"maskadagi oq piksellar: {int((maska > 0).sum())} ({100 * (maska > 0).mean():.2f}%)")
ko_rsat(farq, maska, nom="kadr_farqi.png", sarlavhalar=["absdiff", "threshold 25"],
        izoh="Harakatlangan obyekt ikki joyda ko'rinadi: eski o'rnida va yangisida.")

def fon_ayirish(yaratuvchi, yol=VIDEO, n=150):
    """Har kadrda maska yasaydi va eng katta ikki bo'lakning markazini qaytaradi."""
    fon = yaratuvchi()
    cap = cv2.VideoCapture(str(yol))
    yadro = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
    natijalar, maskalar = [], {}
    for t in range(n):
        ok, kadr = cap.read()
        if not ok:
            break
        m = fon.apply(kadr)
        m[m == 127] = 0                                  # soya piksellari (MOG2) — olib tashlaymiz
        m = cv2.morphologyEx(m, cv2.MORPH_OPEN, yadro)
        if t in (5, 75, 145):
            maskalar[t] = m.copy()
        kont, _ = cv2.findContours(m, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
        katt = sorted([c for c in kont if cv2.contourArea(c) > 150], key=cv2.contourArea, reverse=True)[:2]
        markazlar = []
        for c in katt:
            M = cv2.moments(c)
            markazlar.append((M["m10"] / M["m00"], M["m01"] / M["m00"]))
        natijalar.append({"kadr": t, "topilgan": len(katt), "markazlar": markazlar,
                          "oq %": round(100 * (m > 0).mean(), 2)})
    cap.release()
    return pd.DataFrame(natijalar), maskalar

mog_df, mog_maskalar = fon_ayirish(lambda: cv2.createBackgroundSubtractorMOG2(history=200, varThreshold=25, detectShadows=True))
knn_df, knn_maskalar = fon_ayirish(lambda: cv2.createBackgroundSubtractorKNN(history=200, dist2Threshold=400))
show(pd.DataFrame([
    {"usul": "MOG2", "ikki obyekt topilgan kadrlar": int((mog_df["topilgan"] == 2).sum()),
     "hech narsa topilmagan": int((mog_df["topilgan"] == 0).sum()), "o'rtacha oq %": round(mog_df["oq %"].mean(), 2)},
    {"usul": "KNN", "ikki obyekt topilgan kadrlar": int((knn_df["topilgan"] == 2).sum()),
     "hech narsa topilmagan": int((knn_df["topilgan"] == 0).sum()), "o'rtacha oq %": round(knn_df["oq %"].mean(), 2)},
]))
ko_rsat(*mog_maskalar.values(), nom="mog2_maskalar.png", kenglik=15,
        sarlavhalar=[f"MOG2, kadr {t}" for t in mog_maskalar],
        izoh="Boshida fon hali o'rganilmagan, keyin maska tozalanadi va faqat ikki obyekt qoladi.")

def xatoni_olch(df, nom, chegara=40):
    """Har kadrdagi ikki nishon uchun eng yaqin topilgan markazgacha masofani o'lchaydi."""
    masofalar = []
    for _, q in df.iterrows():
        h = haqiqat.iloc[int(q["kadr"])]
        for nx, ny in [(h["x1"], h["y1"]), (h["x2"], h["y2"])]:
            if not q["markazlar"]:
                masofalar.append(np.inf)
            else:
                masofalar.append(min(((mx - nx) ** 2 + (my - ny) ** 2) ** 0.5 for mx, my in q["markazlar"]))
    topilgan = [d for d in masofalar if d < chegara]
    return {"usul": nom, "tekshirilgan nishonlar": len(masofalar),
            f"{chegara} px ichida topilgan": len(topilgan),
            "topish darajasi %": round(100 * len(topilgan) / len(masofalar), 1),
            "o'rtacha xato, px": round(float(np.mean(topilgan)), 2) if topilgan else None}

show(pd.DataFrame([xatoni_olch(mog_df, "MOG2"), xatoni_olch(knn_df, "KNN")]))

qatorlar = []
for tarix in (20, 100, 500):
    df, _ = fon_ayirish(lambda t=tarix: cv2.createBackgroundSubtractorMOG2(history=t, varThreshold=25, detectShadows=False))
    n = xatoni_olch(df, f"history={tarix}")
    n["o'rtacha oq %"] = round(df["oq %"].mean(), 2)
    qatorlar.append(n)
show(pd.DataFrame(qatorlar))

QURILISH = DATA.parent.parent / "YOLO_Tracking_Kitob" / "datasets" / "pexels" / "13921040_2560x1440.mp4"

def siljish_va_maska(yol, n=60, olcham=(640, 360)):
    cap = cv2.VideoCapture(str(yol))
    fon = cv2.createBackgroundSubtractorMOG2(history=200, varThreshold=25, detectShadows=False)
    oldingi, siljishlar, oq = None, [], []
    namuna = None
    for t in range(n):
        ok, kadr = cap.read()
        if not ok:
            break
        k = cv2.resize(kadr, olcham)
        g = cv2.cvtColor(k, cv2.COLOR_BGR2GRAY).astype(np.float64)
        if oldingi is not None:
            (dx, dy), _ = cv2.phaseCorrelate(oldingi, g)
            siljishlar.append((dx ** 2 + dy ** 2) ** 0.5)
        oldingi = g
        m = fon.apply(k)
        oq.append(100 * (m > 0).mean())
        if t == n - 1:
            namuna = m
    cap.release()
    return float(np.mean(siljishlar)), float(np.mean(oq[10:])), namuna

s1, o1, m1 = siljish_va_maska(VIDEO)
s2, o2, m2 = siljish_va_maska(QURILISH)
show(pd.DataFrame([
    {"video": "harakat.mp4 (qotgan kamera)", "kadrlar orasi siljish, px": round(s1, 2), "maskadagi oq %": round(o1, 2)},
    {"video": "qurilish (kamera suriladi)", "kadrlar orasi siljish, px": round(s2, 2), "maskadagi oq %": round(o2, 2)},
]))
ko_rsat(m1, m2, nom="kamera_qimirlashi.png",
        sarlavhalar=["qotgan kamera — faqat obyektlar", "suriladigan kamera — butun kadr"],
        izoh="Kamera surilsa fon ayirish ma'nosini yo'qotadi: hamma narsa 'harakat' bo'lib chiqadi.")

cap = cv2.VideoCapture(str(VIDEO))
cap.set(cv2.CAP_PROP_POS_FRAMES, 60)
_, f1 = cap.read()
_, f2 = cap.read()
cap.release()
g1 = cv2.cvtColor(f1, cv2.COLOR_BGR2GRAY)
g2 = cv2.cvtColor(f2, cv2.COLOR_BGR2GRAY)
oqim = cv2.calcOpticalFlowFarneback(g1, g2, None, 0.5, 3, 15, 3, 5, 1.2, 0)
kuch, burchak = cv2.cartToPolar(oqim[..., 0], oqim[..., 1])
print(f"oqim tensori: {oqim.shape} (har piksel uchun dx, dy)")
print(f"eng katta siljish: {kuch.max():.2f} px | o'rtacha: {kuch.mean():.3f} px")
print(f"haqiqat: qizil to'rtburchak kadriga 3.0 px, yashil doira 2.2 px siljiydi")

hsv = np.zeros_like(f1)
hsv[..., 0] = burchak * 180 / np.pi / 2
hsv[..., 1] = 255
hsv[..., 2] = cv2.normalize(kuch, None, 0, 255, cv2.NORM_MINMAX)
ko_rsat(cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR), (kuch > 1.0).astype(np.uint8) * 255,
        nom="optik_oqim.png", sarlavhalar=["oqim (rang — yo'nalish)", "kuch > 1 px"],
        izoh="Rang harakat yo'nalishini, yorqinlik esa tezligini bildiradi. Fon qora — u qimirlamaydi.")

h60 = haqiqat.iloc[60]
qatorlar = []
for nom, (cx, cy), r, kutilgan in [("qizil to'rtburchak", (h60["x1"], h60["y1"]), 18, 3.0),
                                   ("yashil doira", (h60["x2"], h60["y2"]), 20, 2.2)]:
    m = np.zeros(kuch.shape, np.uint8)
    cv2.circle(m, (int(cx), int(cy)), r, 255, -1)
    olchangan = float(kuch[m > 0].mean())
    qatorlar.append({"obyekt": nom, "o'lchangan siljish, px": round(olchangan, 2),
                     "haqiqiy siljish, px": kutilgan, "xato, px": round(abs(olchangan - kutilgan), 2)})
fon_m = np.ones(kuch.shape, np.uint8) * 255
for cx, cy, r in [(h60["x1"], h60["y1"], 40), (h60["x2"], h60["y2"], 40)]:
    cv2.circle(fon_m, (int(cx), int(cy)), r, 0, -1)
qatorlar.append({"obyekt": "fon (qimirlamaydi)", "o'lchangan siljish, px": round(float(kuch[fon_m > 0].mean()), 2),
                 "haqiqiy siljish, px": 0.0, "xato, px": round(float(kuch[fon_m > 0].mean()), 2)})
show(pd.DataFrame(qatorlar))

nomzodlar = ["TrackerMIL_create", "TrackerCSRT_create", "TrackerKCF_create", "TrackerGOTURN_create"]
show(pd.DataFrame([{"tracker": n.replace("_create", ""), "mavjudmi": hasattr(cv2, n)} for n in nomzodlar]))
print("opencv-python versiyasi:", cv2.__version__)

import time

def kuzat_mil(n=150):
    cap = cv2.VideoCapture(str(VIDEO))
    ok, kadr = cap.read()
    h0 = haqiqat.iloc[0]
    tr = cv2.TrackerMIL_create()
    tr.init(kadr, (int(h0["x1"] - 18), int(h0["y1"] - 30), 36, 60))
    xatolar, yoqolgan = [], 0
    t0 = time.perf_counter()
    for t in range(1, n):
        ok, kadr = cap.read()
        if not ok:
            break
        topildi, q = tr.update(kadr)
        if not topildi:
            yoqolgan += 1
            continue
        hq = haqiqat.iloc[t]
        xatolar.append(((q[0] + q[2] / 2 - hq["x1"]) ** 2 + (q[1] + q[3] / 2 - hq["y1"]) ** 2) ** 0.5)
    cap.release()
    return xatolar, yoqolgan, time.perf_counter() - t0

def kuzat_shablon(n=150, radius=30, min_ball=0.2):
    """Oldingi joy atrofidagi kichik sohada shablonni qidiradi."""
    cap = cv2.VideoCapture(str(VIDEO))
    ok, kadr = cap.read()
    h0 = haqiqat.iloc[0]
    cx, cy = float(h0["x1"]), float(h0["y1"])
    shab = cv2.cvtColor(kadr, cv2.COLOR_BGR2GRAY)[int(cy) - 30:int(cy) + 30, int(cx) - 18:int(cx) + 18]
    sh_h, sh_w = shab.shape
    xatolar, yoqolgan, ballar = [], 0, []
    t0 = time.perf_counter()
    for t in range(1, n):
        ok, kadr = cap.read()
        if not ok:
            break
        g = cv2.cvtColor(kadr, cv2.COLOR_BGR2GRAY)
        x0 = max(0, int(cx) - sh_w // 2 - radius)                        # qidiruv oynasi
        y0 = max(0, int(cy) - sh_h // 2 - radius)
        soha = g[y0:int(cy) + sh_h // 2 + radius, x0:int(cx) + sh_w // 2 + radius]
        if soha.shape[0] < sh_h or soha.shape[1] < sh_w:
            yoqolgan += 1
            continue
        r = cv2.matchTemplate(soha, shab, cv2.TM_CCOEFF_NORMED)
        _, ball, _, joy = cv2.minMaxLoc(r)
        ballar.append(ball)
        if ball < min_ball:
            yoqolgan += 1
            continue
        cx, cy = x0 + joy[0] + sh_w / 2, y0 + joy[1] + sh_h / 2
        hq = haqiqat.iloc[t]
        xatolar.append(((cx - hq["x1"]) ** 2 + (cy - hq["y1"]) ** 2) ** 0.5)
    cap.release()
    return xatolar, yoqolgan, time.perf_counter() - t0, ballar

qatorlar = []
for chegara in (0.5, 0.4, 0.3, 0.2, 0.1):
    xat, yoq, dt, ballar = kuzat_shablon(min_ball=chegara)
    qatorlar.append({"min_ball": chegara, "kuzatilgan": len(xat), "yo'qotilgan": yoq,
                     "o'rtacha xato, px": round(float(np.mean(xat)), 2) if xat else None})
show(pd.DataFrame(qatorlar))
_, _, _, ballar = kuzat_shablon(min_ball=0.0)
print(f"haqiqiy ballar taqsimoti — eng kichigi: {min(ballar):.3f}, "
      f"o'rtacha: {np.mean(ballar):.3f}, eng kattasi: {max(ballar):.3f}")

qatorlar = []
xat, yoq, dt = kuzat_mil()
qatorlar.append({"usul": "TrackerMIL", "kuzatilgan kadrlar": len(xat), "yo'qotilgan": yoq,
                 "o'rtacha xato, px": round(float(np.mean(xat)), 2),
                 "eng katta xato, px": round(float(np.max(xat)), 1), "kadriga, ms": round(dt / 149 * 1000, 2)})
xat, yoq, dt, _ = kuzat_shablon(min_ball=0.2)
qatorlar.append({"usul": "o'zimiz yozgan (shablon)", "kuzatilgan kadrlar": len(xat), "yo'qotilgan": yoq,
                 "o'rtacha xato, px": round(float(np.mean(xat)), 2),
                 "eng katta xato, px": round(float(np.max(xat)), 1), "kadriga, ms": round(dt / 149 * 1000, 2)})
show(pd.DataFrame(qatorlar))