Zonalar va chiziqlar: sanash, vaqt va qoidalar

import inspect
from pathlib import Path

import cv2
import numpy as np
import pandas as pd
import torch
import torchvision
import matplotlib.pyplot as plt
from ultralytics import YOLO
from ultralytics.engine.results import Boxes
from ultralytics.trackers import BYTETracker
from ultralytics.utils import LOGGER, YAML, IterableSimpleNamespace
from ultralytics.utils.checks import check_yaml

LOGGER.setLevel("ERROR")
MOT = Path("datasets/MOT17/train/MOT17-09-FRCNN")
FPS = 30
gt = np.loadtxt(MOT / "gt" / "gt.txt", delimiter=",")
piyoda = gt[(gt[:, 7] == 1) & (gt[:, 6] == 1)]
gt_trek = np.c_[piyoda[:, 0:2], piyoda[:, 2:4], piyoda[:, 2:4] + piyoda[:, 4:6]]   # (kadr, id, x1, y1, x2, y2)

# 11-bobdagi kabi: saqlangan YOLO11n box lari ustida ByteTrack
d = np.loadtxt("out/mot17/MOT17-09_yolo11n_1280.txt", delimiter=",")
det = {k: np.c_[d[d[:, 0] == k][:, 2:4], d[d[:, 0] == k][:, 2:4] + d[d[:, 0] == k][:, 4:6], d[d[:, 0] == k][:, 6]]
       for k in range(1, 526)}
BYTETracker.reset_id()
tracker = BYTETracker(args=IterableSimpleNamespace(**YAML.load(check_yaml("bytetrack.yaml"))), frame_rate=FPS)
trek = np.array([(k, int(t[4]), *t[:4]) for k in range(1, 526)
                 for t in tracker.update(Boxes(np.c_[det[k], np.zeros(len(det[k]))], (1080, 1920)), None)])

def oyoq(boxlar):
    """xyxy box lar -> oyoq nuqtalari (pastki tomon o'rtasi)."""
    return np.c_[(boxlar[:, 0] + boxlar[:, 2]) / 2, boxlar[:, 3]]

print(f"GT: {len(np.unique(gt_trek[:, 1]))} odam, {len(gt_trek)} box | ByteTrack: {len(np.unique(trek[:, 1]))} ID, {len(trek)} box")

def c(a, b, p):
    return (b[0] - a[0]) * (p[1] - a[1]) - (b[1] - a[1]) * (p[0] - a[0])

def kesib_otish(treklar, A, B):
    """Har bir trek uchun AB kesmani kesib o'tish hodisalari: (kadr, id, yo'nalish)."""
    hodisalar = []
    for tid in np.unique(treklar[:, 1]):
        t = treklar[treklar[:, 1] == tid]
        t = t[np.argsort(t[:, 0])]
        f = oyoq(t[:, 2:6])
        for i in range(1, len(f)):
            if c(A, B, f[i - 1]) * c(A, B, f[i]) < 0 and c(f[i - 1], f[i], A) * c(f[i - 1], f[i], B) < 0:
                hodisalar.append((int(t[i, 0]), int(tid), "chapga" if c(A, B, f[i]) > 0 else "o'ngga"))
    return hodisalar

def moslashtir(gt_h, bizniki, oyna=30):
    """Har bir sanalgan hodisani yo'nalishi bir xil, vaqti +-1 soniya ichidagi GT hodisasi bilan juftlaydi."""
    band, togri = set(), 0
    for k, _, yon in bizniki:
        nomzod = [j for j, (gk, _, gy) in enumerate(gt_h) if j not in band and gy == yon and abs(gk - k) <= oyna]
        if nomzod:
            band.add(min(nomzod, key=lambda j: abs(gt_h[j][0] - k)))
            togri += 1
    return togri, len(bizniki) - togri, len(gt_h) - togri

chiziqlar = {"x = 700": ((700, 500), (700, 1080)), "x = 960 (o'rta)": ((960, 500), (960, 1080)),
             "x = 1300": ((1300, 450), (1300, 1080))}
qatorlar = []
for nom, (A, B) in chiziqlar.items():
    g, b = kesib_otish(gt_trek, A, B), kesib_otish(trek, A, B)
    tp, fp, fn = moslashtir(g, b)
    qatorlar.append({"chiziq": nom, "GT: chapga": sum(h[2] == "chapga" for h in g), "GT: o'ngga": sum(h[2] == "o'ngga" for h in g),
                     "tracker: chapga": sum(h[2] == "chapga" for h in b), "tracker: o'ngga": sum(h[2] == "o'ngga" for h in b),
                     "to'g'ri": tp, "ortiqcha": fp, "o'tkazib yuborilgan": fn})
show(pd.DataFrame(qatorlar))

from ultralytics.solutions.object_counter import ObjectCounter

kod = inspect.getsource(ObjectCounter.count_objects).splitlines()
print("\n".join(q.rstrip() for q in kod if any(s in q for s in ("counted_ids", "Vertical region", "current_centroid[0] >", "intersects"))))

def ichidami(p, zona):
    """Nur tashlash: p dan o'ngga ketgan nur zona tomonlarini necha marta kesadi."""
    x, y = p
    ichida = False
    for i in range(len(zona)):
        (x1, y1), (x2, y2) = zona[i], zona[(i + 1) % len(zona)]
        if (y1 > y) != (y2 > y):                                   # tomon nur balandligini kesib o'tadi
            kesish_x = x1 + (y - y1) * (x2 - x1) / (y2 - y1)
            if x < kesish_x:
                ichida = not ichida
    return ichida

zona = np.array([(150, 600), (760, 600), (820, 800), (100, 800)], float)   # do'kon eshigi ichkarisi, pol
rng = np.random.default_rng(0)
nuqtalar = rng.uniform([0, 450], [1000, 950], size=(20000, 2))
bizniki = np.array([ichidami(p, zona) for p in nuqtalar])
opencv = np.array([cv2.pointPolygonTest(zona.astype(np.float32), tuple(map(float, p)), False) > 0 for p in nuqtalar])
print(f"20 000 tasodifiy nuqta: OpenCV pointPolygonTest bilan farq qilganlar — {int((bizniki != opencv).sum())}")

kadr = cv2.imread(str(MOT / "img1" / "000060.jpg"))[:, :, ::-1]
_, ax = plt.subplots(figsize=(10, 5.6))
ax.imshow(kadr)
ax.add_patch(plt.Polygon(zona, fill=True, alpha=0.25, color="yellow"))
for nom, (A, B) in chiziqlar.items():
    ax.plot([A[0], B[0]], [A[1], B[1]], color="red", lw=2)
    ax.text(A[0] + 8, A[1] + 30, nom, color="red", fontsize=9, bbox=dict(fc="white", ec="none", alpha=0.7))
f = oyoq(gt_trek[gt_trek[:, 0] % 3 == 0][:, 2:6])
ax.scatter(f[:, 0], f[:, 1], s=2, color="magenta")
ax.set_xlim(0, 1920)
ax.set_ylim(1080, 0)
ax.axis("off")
fig("zona_chiziqlar.png", "Sariq — zona (do'kon eshigi ichidagi pol), qizil — sanash chiziqlari, pushti nuqtalar — GT odamlarining oyoq nuqtalari (har 3-kadr).")

def zonada(treklar):
    return np.array([ichidami(p, zona) for p in oyoq(treklar[:, 2:6])])

box_det = np.array([(k, -1, *b[:4]) for k in det for b in det[k] if b[4] >= 0.25])   # tracking siz, faqat detector
gt_ichi, trek_ichi, det_ichi = zonada(gt_trek), zonada(trek), zonada(box_det)
band = pd.DataFrame({"GT": np.bincount(gt_trek[gt_ichi, 0].astype(int), minlength=526)[1:],
                     "tracker": np.bincount(trek[trek_ichi, 0].astype(int), minlength=526)[1:],
                     "faqat detector": np.bincount(box_det[det_ichi, 0].astype(int), minlength=526)[1:]})
print("zonadagi odamlar soni, kadrlar bo'yicha:")
show(band.describe().loc[["mean", "max"]].rename(index={"mean": "o'rtacha", "max": "eng ko'p"}).round(2))

def kutish(treklar, ichi):
    """Har bir ID zonada necha soniya bo'ldi (faqat zonaga kirganlar)."""
    ids, soni = np.unique(treklar[ichi, 1], return_counts=True)
    return pd.Series(soni / FPS, index=ids.astype(int))

gk, tk = kutish(gt_trek, gt_ichi), kutish(trek, trek_ichi)
show(pd.DataFrame([{"manba": "GT", "zonaga kirgan ID lar": len(gk), "o'rtacha, s": gk.mean(), "eng uzoq, s": gk.max(), "jami odam-soniya": gk.sum()},
                   {"manba": "tracker", "zonaga kirgan ID lar": len(tk), "o'rtacha, s": tk.mean(), "eng uzoq, s": tk.max(), "jami odam-soniya": tk.sum()}]).round(2))

_, ax = plt.subplots(figsize=(10, 2.8))
for ustun, rang in (("GT", "gray"), ("tracker", "#2563eb")):
    ax.plot(band.index + 1, band[ustun], label=ustun, color=rang, lw=1.5)
ax.set_xlabel("kadr")
ax.set_ylabel("zonadagi odamlar")
ax.legend()
fig("zona_band.png", "Zonadagi odamlar soni har kadrda: GT va tracker.")

xarita = np.zeros((1080, 1920), np.float32)
for x, y in oyoq(trek[:, 2:6]).astype(int):
    if 0 <= x < 1920 and 0 <= y < 1080:
        xarita[y, x] += 1
xarita = cv2.GaussianBlur(xarita, (0, 0), 25)                     # har nuqtani ~25 px lik "dog'" ga yoyamiz
qiymat = xarita / xarita.max()
rang = plt.cm.inferno(qiymat)                                      # har piksel uchun rang (RGBA)
rang[..., 3] = np.clip(np.sqrt(qiymat) * 1.2, 0, 0.85)             # shaffoflik qiymatga qarab: bo'sh joy ko'rinmaydi
_, ax = plt.subplots(figsize=(10, 5.6))
ax.imshow(kadr)
ax.imshow(rang)
ax.axis("off")
fig("issiqlik.png", "Tracker oyoq nuqtalaridan issiqlik xaritasi: 525 kadr davomida odamlar eng ko'p bo'lgan joylar.")

ppe = Path("datasets/construction-ppe")
model = YOLO("out/train/ppe_coco/weights/best.pt")
KASKA, ODAM, KASKASIZ = 0, 6, 7

def bosh_holati(odam, kaskalar, kaskasizlar, ulush=0.3):
    x1, y1, x2, y2 = odam
    bosh = lambda b: x1 <= (b[0] + b[2]) / 2 <= x2 and y1 - 0.1 * (y2 - y1) <= (b[1] + b[3]) / 2 <= y1 + ulush * (y2 - y1)
    if any(bosh(b) for b in kaskalar):
        return "kaskali"
    if any(bosh(b) for b in kaskasizlar):
        return "kaskasiz"
    return "noma'lum"

qatorlar = []
for yol in sorted((ppe / "images" / "test").iterdir()):
    rasm = cv2.imread(str(yol))
    H, W = rasm.shape[:2]
    lab = np.loadtxt(ppe / "labels" / "test" / f"{yol.stem}.txt", ndmin=2).reshape(-1, 5)
    g = np.c_[(lab[:, 1] - lab[:, 3] / 2) * W, (lab[:, 2] - lab[:, 4] / 2) * H, (lab[:, 1] + lab[:, 3] / 2) * W, (lab[:, 2] + lab[:, 4] / 2) * H]
    r = model.predict(rasm, conf=0.25, verbose=False)[0]
    b, s = r.boxes.xyxy.cpu().numpy(), r.boxes.cls.cpu().numpy()
    for odam in g[lab[:, 0] == ODAM]:
        haqiqat = bosh_holati(odam, g[lab[:, 0] == KASKA], g[lab[:, 0] == KASKASIZ])
        if haqiqat == "noma'lum":
            continue
        topilgan = b[s == ODAM]
        iou = torchvision.ops.box_iou(torch.tensor(odam[None]), torch.tensor(topilgan)).numpy()[0] if len(topilgan) else np.zeros(1)
        if iou.max() < 0.5:
            qatorlar.append({"haqiqat": haqiqat, "A: mantiq": "odam topilmadi", "B: no_helmet sinfi": "odam topilmadi"})
            continue
        q = topilgan[iou.argmax()]
        qatorlar.append({"haqiqat": haqiqat,
                         "A: mantiq": "kaskali" if bosh_holati(q, b[s == KASKA], []) == "kaskali" else "kaskasiz",
                         "B: no_helmet sinfi": "kaskasiz" if bosh_holati(q, [], b[s == KASKASIZ]) == "kaskasiz" else "kaskali"})
natija = pd.DataFrame(qatorlar)
for usul in ("A: mantiq", "B: no_helmet sinfi"):
    show(pd.crosstab(natija["haqiqat"], natija[usul]).rename_axis(index=f"haqiqat \\ {usul}"))
topildi = natija[natija["A: mantiq"] != "odam topilmadi"]
for usul in ("A: mantiq", "B: no_helmet sinfi"):
    kasiz, kali = topildi[topildi["haqiqat"] == "kaskasiz"], topildi[topildi["haqiqat"] == "kaskali"]
    print(f"{usul:20s}: kaskasizlarning {(kasiz[usul] == 'kaskasiz').mean():.0%} i topildi, "
          f"kaskalilarning {(kali[usul] == 'kaskasiz').mean():.1%} i uchun soxta signal")