Kamera tanlash: piksel zichligi, ob'ektiv va masofa

import json
import re
import subprocess
from pathlib import Path

import cv2
import numpy as np
import pandas as pd
import torch
import torchvision
import matplotlib.pyplot as plt
from scipy.optimize import linear_sum_assignment
from ultralytics import YOLO
from ultralytics.utils import LOGGER

LOGGER.setLevel("ERROR")
WT = Path("datasets/wildtrack/Wildtrack_dataset")
qatorlar = []
for c, nom, kor in (("C1", "CVLab1", 0), ("C2", "CVLab2", 1), ("C6", "IDIAP2", 5)):
    fs = cv2.FileStorage(str(WT / "calibrations" / "intrinsic_zero" / f"intr_{nom}.xml"), cv2.FILE_STORAGE_READ)
    K = fs.getNode("camera_matrix").mat()
    matn = (WT / "calibrations" / "extrinsic" / f"extr_{nom}.xml").read_text()
    rvec, t = (np.array(re.search(f"<{teg}>(.*?)</{teg}>", matn, re.S).group(1).split(), float) for teg in ("rvec", "tvec"))
    R = cv2.Rodrigues(rvec)[0]
    boy = []
    for k in range(0, 750, 5):
        for p in json.load(open(WT / "annotations_positions" / f"{k:08d}.json")):
            v = p["views"][kor]
            if v["xmin"] < 0 or v["ymin"] <= 0 or v["ymax"] >= 1079:             # kadr chetida kesilgan box lar emas
                continue
            X = np.array([-300 + 2.5 * (p["positionID"] % 480), -900 + 2.5 * (p["positionID"] // 480), 0.0])
            Z = (R @ X + t)[2] / 100                                             # kameragacha chuqurlik, metr
            boy.append((v["ymax"] - v["ymin"]) * Z / K[1, 1])
    qatorlar.append({"kamera": c, "f_y, px": K[1, 1], "box lar": len(boy), "box × Z / f, m (median)": np.median(boy)})
show(pd.DataFrame(qatorlar).round(2))

MOT = Path("datasets/MOT17/train")
VIDEOLAR = ["MOT17-02", "MOT17-04", "MOT17-05", "MOT17-09", "MOT17-10", "MOT17-11", "MOT17-13"]
MASSHTAB = [1, 1 / 2, 1 / 3, 1 / 4, 1 / 6]
ORALIQLAR = [8, 12, 16, 24, 32, 48, 64, 96, 128, 10_000]

def iou_matritsa(a, b):
    return torchvision.ops.box_iou(torch.tensor(np.asarray(a, float)), torch.tensor(np.asarray(b, float))).numpy()

def topildi(G, D):
    """G ning qaysi box lari D dagi biror box bilan IoU >= 0.5 da moslandi (Venger)."""
    t = np.zeros(len(G), bool)
    if len(G) and len(D):
        M = iou_matritsa(G, D)
        r, c = linear_sum_assignment(-M)
        t[r[M[r, c] >= 0.5]] = True
    return t

def kichraytirib_top(model, rasm, s, **kw):
    """Rasmni s marta kichraytiradi va modelga o'z o'lchamida beradi (imgsz — 32 ga karrali)."""
    kichik = cv2.resize(rasm, (max(1, round(rasm.shape[1] * s)), max(1, round(rasm.shape[0] * s))), interpolation=cv2.INTER_AREA)
    imgsz = int(np.ceil(max(kichik.shape[:2]) / 32) * 32)
    return model.predict(kichik, imgsz=imgsz, conf=0.25, device=0, verbose=False, **kw)[0].boxes

model = YOLO("weights/yolo11n.pt")
qatorlar = []
for video in VIDEOLAR:
    gt = np.loadtxt(MOT / f"{video}-FRCNN" / "gt" / "gt.txt", delimiter=",")
    gt = gt[gt[:, 7] == 1]
    kadr_yollari = sorted((MOT / f"{video}-FRCNN" / "img1").iterdir())
    for k in range(1, len(kadr_yollari) + 1, 10):
        rasm = cv2.imread(str(kadr_yollari[k - 1]))
        H, W = rasm.shape[:2]
        G = gt[gt[:, 0] == k]
        B = np.c_[G[:, 2:4], G[:, 2:4] + G[:, 4:6]]
        yaxshi = (G[:, 8] >= 0.8) & (B[:, 0] >= 0) & (B[:, 1] >= 0) & (B[:, 2] <= W) & (B[:, 3] <= H)
        for s in MASSHTAB:
            t = topildi(B * s, kichraytirib_top(model, rasm, s, classes=[0]).xyxy.cpu().numpy())
            qatorlar += [(video, s, h * s, x) for h, x in zip(G[yaxshi, 5], t[yaxshi])]
odam = pd.DataFrame(qatorlar, columns=["video", "masshtab", "balandlik", "topildi"])
odam["oraliq, px"] = pd.cut(odam["balandlik"], ORALIQLAR, right=False)
jadval = odam.groupby(["oraliq, px", "masshtab"], observed=True)["topildi"].mean().unstack() * 100
jadval.columns = [f"s = 1/{round(1 / s)}" if s < 1 else "asl" for s in jadval.columns]
jadval["hammasi"] = odam.groupby("oraliq, px", observed=True)["topildi"].mean() * 100
jadval["odamlar"] = odam.groupby("oraliq, px", observed=True).size()
show(jadval.round(1))

ppe = YOLO("out/train/ppe_coco/weights/best.pt")                          # 7-bob: 0 — helmet, 6 — Person
qatorlar, nisbat = [], []
for yol in sorted(Path("datasets/construction-ppe/images/test").iterdir()):
    rasm = cv2.imread(str(yol))
    H, W = rasm.shape[:2]
    L = np.loadtxt(Path(str(yol).replace("/images/", "/labels/")).with_suffix(".txt"), ndmin=2)
    B = np.c_[(L[:, 1] - L[:, 3] / 2) * W, (L[:, 2] - L[:, 4] / 2) * H, (L[:, 1] + L[:, 3] / 2) * W, (L[:, 2] + L[:, 4] / 2) * H]
    kaskalar, odamlar = B[L[:, 0] == 0], B[L[:, 0] == 6]
    for b in kaskalar:                                                   # kaska aynan bitta odamning boshida bo'lsa
        egasi = [o for o in odamlar if o[0] - 5 <= b[0] and b[2] <= o[2] + 5 and o[1] - 5 <= b[1] <= o[1] + 0.3 * (o[3] - o[1])]
        if len(egasi) == 1:
            nisbat.append((b[3] - b[1]) / (egasi[0][3] - egasi[0][1]))
    for s in MASSHTAB:
        r = kichraytirib_top(ppe, rasm, s)
        t = topildi(kaskalar * s, r.xyxy.cpu().numpy()[r.cls.cpu().numpy() == 0])
        qatorlar += [(s, h * s, x) for h, x in zip(kaskalar[:, 3] - kaskalar[:, 1], t)]
kaska = pd.DataFrame(qatorlar, columns=["masshtab", "balandlik", "topildi"])
kaska["oraliq, px"] = pd.cut(kaska["balandlik"], [4, 8, 12, 16, 24, 32, 48, 64, 10_000], right=False)
show(kaska.groupby("oraliq, px", observed=True)["topildi"].agg(recall=lambda x: 100 * x.mean(), kaskalar="size").round(1))
print(f"kaska balandligi / odam balandligi: median {np.median(nisbat):.3f} ({len(nisbat)} juft)")

_, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4.3), sharey=True)
for s in MASSHTAB:
    q = odam[odam["masshtab"] == s].groupby("oraliq, px", observed=True)["topildi"].mean() * 100
    ax1.plot([o.left for o in q.index], q.values, marker="o", ms=4, label=f"s = 1/{round(1 / s)}" if s < 1 else "asl kadr")
q = kaska.groupby("oraliq, px", observed=True)["topildi"].mean() * 100
ax2.plot([o.left for o in q.index], q.values, marker="o", color="C3")
for ax, nom, q in ((ax1, "odam (YOLO11n)", odam), (ax2, "kaska (7-bob modeli)", kaska)):
    ax.set_xscale("log", base=2)
    ax.minorticks_off()
    chegara = [o.left for o in q["oraliq, px"].cat.categories]
    ax.set_xticks(chegara, [str(c) for c in chegara])
    ax.set_xlabel("box balandligi, modelga kiradigan rasmda, px (oraliq boshi)")
    ax.set_title(nom, fontsize=10)
    ax.axhline(90, color="gray", lw=0.7, ls="--")
ax1.set_ylabel("recall, %")
ax1.legend(fontsize=8)
fig("piksel_recall.png", "Recall box balandligiga qarab. Chapda: bir xil kadrlar turli masshtabda — kichraytirilgan tiniq odam asl kadrdagi uzoq odamdan osonroq topiladi.")

BOY = 1.7                                                                  # odam bo'yi, m
ODAM_PX = 64                                                               # yuqoridagi jadvaldan: ishonchli topish
KASKA_PX = 24                                                              # kaska jadvalidan
KASKA_NISBAT = np.median(nisbat)
YUZ_PX_M = 45 / 0.16                                                       # 13-bob: 45 px yuz, yuz kengligi 16 sm

def masofa(zichlik, W, hfov):
    """Kerakli piksel zichligi (px/m) shu masofagacha bajariladi, metr."""
    return W / (2 * zichlik * np.tan(np.radians(hfov) / 2))

qatorlar = []
for hfov in (100, 80, 60, 40, 25):
    q = {"HFOV, °": hfov}
    for imgsz in (640, 1280):
        q[f"odam, imgsz {imgsz}"] = masofa(ODAM_PX / BOY, imgsz, hfov)
        q[f"kaska, imgsz {imgsz}"] = masofa(KASKA_PX / KASKA_NISBAT / BOY, imgsz, hfov)
    for nom, W in (("2 MP", 1920), ("4 MP", 2560), ("8 MP", 3840)):
        q[f"yuz, {nom}"] = masofa(YUZ_PX_M, W, hfov)
    qatorlar.append(q)
show(pd.DataFrame(qatorlar).round(1))

video = "MOT17-09"
papka = MOT / f"{video}-FRCNN"
gt = np.loadtxt(papka / "gt" / "gt.txt", delimiter=",")
gt = gt[gt[:, 7] == 1]
W, H = 1920, 1080
yaxshi = (gt[:, 8] >= 0.8) & (gt[:, 2] >= 0) & (gt[:, 3] >= 0) & (gt[:, 2] + gt[:, 4] <= W) & (gt[:, 3] + gt[:, 5] <= H)

def baho(kadrlar):
    """kadrlar: (kadr raqami, rasm). Qaytaradi: recall, % va GT ga mos kelmagan box lar."""
    tp = jami = ortiqcha = 0
    for k, rasm in kadrlar:
        D = model.predict(rasm, classes=[0], conf=0.25, imgsz=1280, device=0, verbose=False)[0].boxes.xyxy.cpu().numpy()
        m = gt[:, 0] == k
        t = topildi(np.c_[gt[m, 2:4], gt[m, 2:4] + gt[m, 4:6]], D)
        tp, jami, ortiqcha = tp + t[yaxshi[m]].sum(), jami + yaxshi[m].sum(), ortiqcha + len(D) - t.sum()
    return 100 * tp / jami, ortiqcha

def videodan(fayl, qadam):
    cap, k = cv2.VideoCapture(str(fayl)), 1
    while True:
        ok, rasm = cap.read()
        if not ok:
            return
        yield k, rasm
        k += qadam

yollar = sorted((papka / "img1").iterdir())
qatorlar = []
for nom, kadrlar in (("asl JPEG kadrlar", ((k, cv2.imread(str(p))) for k, p in enumerate(yollar, 1))),
                     ("kulrang (tungi rejim kabi)", ((k, cv2.cvtColor(cv2.cvtColor(cv2.imread(str(p)), cv2.COLOR_BGR2GRAY), cv2.COLOR_GRAY2BGR))
                                                     for k, p in enumerate(yollar, 1)))):
    recall, ortiqcha = baho(kadrlar)
    qatorlar.append({"tasvir": nom, "recall, %": recall, "mos kelmagan box lar": ortiqcha})

Path("out/kamera").mkdir(parents=True, exist_ok=True)
for kodek, fps, kbit in (("H.264", 30, 4000), ("H.264", 30, 2000), ("H.264", 30, 1000), ("H.264", 30, 500), ("H.264", 30, 250),
                         ("H.264", 15, 1000), ("H.264", 15, 500), ("H.265", 30, 1000), ("H.265", 30, 500), ("H.265", 30, 250)):
    fayl = Path(f"out/kamera/{video}_{kodek}_{fps}fps_{kbit}k.mp4")
    if not fayl.exists():
        kod = ["-c:v", "libx264"] if kodek == "H.264" else ["-c:v", "libx265", "-x265-params", "log-level=error"]
        filtr = ["-vf", r"select=not(mod(n\,2)),setpts=N/15/TB"] if fps == 15 else []      # 15 fps: har ikkinchi kadr
        subprocess.run(["ffmpeg", "-y", "-loglevel", "error", "-framerate", "30", "-i", str(papka / "img1" / "%06d.jpg"), *filtr,
                        "-r", str(fps), *kod, "-preset", "medium", "-b:v", f"{kbit}k", "-maxrate", f"{kbit}k", "-bufsize", f"{2 * kbit}k",
                        "-pix_fmt", "yuv420p", str(fayl)], check=True)
    recall, ortiqcha = baho(videodan(fayl, 30 // fps))
    qatorlar.append({"tasvir": f"{kodek}, {fps} fps, {kbit} kbit/s", "kadrga kbit": kbit / fps, "fayl, KB": fayl.stat().st_size // 1024,
                     "recall, %": recall, "mos kelmagan box lar": ortiqcha})
show(pd.DataFrame(qatorlar).round(1))