Loyiha: hujjat skaneri

def burchaklarni_top(rasm, ishchi_kenglik=600):
    """Rasmdagi eng katta to'rtburchakni topadi. Topilmasa None qaytaradi.

    Koordinatalar asl rasm o'lchamida qaytariladi.
    """
    koef = ishchi_kenglik / rasm.shape[1]
    kichik = cv2.resize(rasm, (ishchi_kenglik, int(rasm.shape[0] * koef)))
    gray = cv2.cvtColor(kichik, cv2.COLOR_BGR2GRAY)
    silliq = cv2.GaussianBlur(gray, (5, 5), 0)
    chekka = cv2.Canny(silliq, 50, 150)
    chekka = cv2.morphologyEx(chekka, cv2.MORPH_CLOSE, np.ones((5, 5), np.uint8))
    kont, _ = cv2.findContours(chekka, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    eng_kichik_maydon = 0.2 * kichik.shape[0] * kichik.shape[1]          # varaq kadrning kamida 20% i
    for c in sorted(kont, key=cv2.contourArea, reverse=True)[:5]:
        if cv2.contourArea(c) < eng_kichik_maydon:
            break
        yaqin = cv2.approxPolyDP(c, 0.02 * cv2.arcLength(c, True), True)
        if len(yaqin) == 4:
            return yaqin.reshape(4, 2) / koef                            # asl o'lchamga qaytaramiz
    return None

hujjat = cv2.imread(str(RASM / "hujjat.jpg"))
burchak = burchaklarni_top(hujjat)
KUTILGAN = np.array([[150, 90], [720, 170], [650, 940], [90, 830]], np.float32)
print("topildimi:", burchak is not None)
print("topilgan burchaklar:\n", np.round(burchak).astype(int))

def burchaklarni_tartibla(p):
    """4 nuqtani [yuqori-chap, yuqori-o'ng, past-o'ng, past-chap] tartibiga keltiradi."""
    p = np.asarray(p, np.float32).reshape(4, 2)
    t = np.zeros((4, 2), np.float32)
    yigindi = p.sum(axis=1)
    t[0] = p[np.argmin(yigindi)]        # x+y eng kichik -> yuqori-chap
    t[2] = p[np.argmax(yigindi)]        # x+y eng katta  -> past-o'ng
    ayirma = np.diff(p, axis=1).ravel()
    t[1] = p[np.argmin(ayirma)]         # y-x eng kichik -> yuqori-o'ng
    t[3] = p[np.argmax(ayirma)]         # y-x eng katta  -> past-chap
    return t

tartibli = burchaklarni_tartibla(burchak)
nomlar = ["yuqori-chap", "yuqori-o'ng", "past-o'ng", "past-chap"]
xato = np.linalg.norm(tartibli - KUTILGAN, axis=1)
show(pd.DataFrame([{"burchak": n, "topilgan": f"({t[0]:.0f}, {t[1]:.0f})",
                    "haqiqiy": f"({k[0]:.0f}, {k[1]:.0f})", "xato, px": round(float(e), 1)}
                   for n, t, k, e in zip(nomlar, tartibli, KUTILGAN, xato)]))

# tartiblash aralashtirilgan kirishda ham ishlashi kerak
rng = np.random.default_rng(0)
mos = all(np.allclose(burchaklarni_tartibla(burchak[rng.permutation(4)]), tartibli) for _ in range(20))
print("20 ta tasodifiy tartibda ham bir xil natija:", mos)

def chiqish_olchami(t):
    """Tartiblangan burchaklardan chiqish rasmining kengligi va balandligini hisoblaydi."""
    kenglik = max(np.linalg.norm(t[1] - t[0]), np.linalg.norm(t[2] - t[3]))
    balandlik = max(np.linalg.norm(t[3] - t[0]), np.linalg.norm(t[2] - t[1]))
    return int(round(kenglik)), int(round(balandlik))

w, h = chiqish_olchami(tartibli)
print(f"hisoblangan chiqish o'lchami: {w}x{h}")
print(f"asl varaq o'lchami (hujjat_toza.png): 640x900")
print(f"tomonlar nisbati — hisoblangan {w / h:.3f}, haqiqiy {640 / 900:.3f}")

def skanerla(rasm, blockSize=31, C=15, olcham=None, tozalash=False):
    """Hujjat suratidan tekis, oq-qora skan yasaydi.

    olcham=None bo'lsa chiqish o'lchami to'rtburchakdan hisoblanadi.
    Qaytaradi: (natija, ma'lumot). Burchak topilmasa natija None bo'ladi.
    """
    burchak = burchaklarni_top(rasm)
    if burchak is None:
        return None, {"xato": "to'rtburchak topilmadi"}
    t = burchaklarni_tartibla(burchak)
    w, h = olcham if olcham else chiqish_olchami(t)
    if w < 50 or h < 50:
        return None, {"xato": f"topilgan soha juda kichik: {w}x{h}"}
    nishon = np.float32([[0, 0], [w, 0], [w, h], [0, h]])
    M = cv2.getPerspectiveTransform(t, nishon)
    togri = cv2.warpPerspective(rasm, M, (w, h))
    gray = cv2.cvtColor(togri, cv2.COLOR_BGR2GRAY)
    natija = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                   cv2.THRESH_BINARY, blockSize, C)
    if tozalash:
        natija = cv2.morphologyEx(natija, cv2.MORPH_CLOSE, np.ones((2, 2), np.uint8))
    return natija, {"burchaklar": t, "o'lcham": (w, h), "rangli": togri, "kulrang": gray}

natija, info = skanerla(hujjat)
print("o'lcham:", info["o'lcham"])
ko_rsat(hujjat, info["rangli"], natija, nom="skaner_qadamlar.png", kenglik=14,
        sarlavhalar=["asl surat", "to'g'rilangan", "oq-qora skan"],
        izoh="Uch qadam: burchaklarni topish, perspektivani to'g'rilash, matnni ajratish.")

TOZA = cv2.imread(str(RASM / "hujjat_toza.png"), cv2.IMREAD_GRAYSCALE)
_, HAQIQAT = cv2.threshold(TOZA, 128, 255, cv2.THRESH_BINARY_INV)        # haqiqiy matn piksellari

OLCHOV = (HAQIQAT.shape[1], HAQIQAT.shape[0])                             # 640x900 — haqiqat geometriyasi

def sifat(binar):
    """Skan natijasini haqiqat bilan solishtiradi: matn piksellari bo'yicha aniqlik/to'liqlik/F1."""
    if binar is None or binar.shape != HAQIQAT.shape:
        return 0.0, 0.0, 0.0
    topilgan = binar == 0                                                 # qora = siyoh
    haqiqiy = HAQIQAT > 0
    tp = int((topilgan & haqiqiy).sum())
    fp = int((topilgan & ~haqiqiy).sum())
    fn = int((~topilgan & haqiqiy).sum())
    aniq = tp / max(tp + fp, 1)
    toliq = tp / max(tp + fn, 1)
    return round(100 * aniq, 1), round(100 * toliq, 1), round(100 * 2 * aniq * toliq / max(aniq + toliq, 1e-9), 1)

olchov_natija, _ = skanerla(hujjat, olcham=OLCHOV)
a, t, f1 = sifat(olchov_natija)
print(f"skaner natijasi — aniqlik {a}%, to'liqlik {t}%, F1 {f1}%")

_, info_olchov = skanerla(hujjat, olcham=OLCHOV)
tekis = info_olchov["kulrang"]                                            # to'g'rilangan kulrang varaq
_, otsu = cv2.threshold(tekis, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
_, global_140 = cv2.threshold(tekis, 140, 255, cv2.THRESH_BINARY)
show(pd.DataFrame([
    {"usul": "global 140", **dict(zip(["aniqlik %", "to'liqlik %", "F1 %"], sifat(global_140)))},
    {"usul": "Otsu", **dict(zip(["aniqlik %", "to'liqlik %", "F1 %"], sifat(otsu)))},
    {"usul": "adaptive (skaner)", **dict(zip(["aniqlik %", "to'liqlik %", "F1 %"], sifat(olchov_natija)))},
]))

def qolda_skaner(rasm, burchaklar, blockSize=31, C=15):
    w, h = OLCHOV
    M = cv2.getPerspectiveTransform(np.float32(burchaklar), np.float32([[0, 0], [w, 0], [w, h], [0, h]]))
    g = cv2.warpPerspective(cv2.cvtColor(rasm, cv2.COLOR_BGR2GRAY), M, (w, h))
    return cv2.adaptiveThreshold(g, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, blockSize, C)

show(pd.DataFrame([
    {"burchaklar": "qo'lda yozilgan (aniq)",
     **dict(zip(["aniqlik %", "to'liqlik %", "F1 %"], sifat(qolda_skaner(hujjat, KUTILGAN))))},
    {"burchaklar": "algoritm topgan (~1.2 px xato)",
     **dict(zip(["aniqlik %", "to'liqlik %", "F1 %"], sifat(olchov_natija)))},
]))

qatorlar = []
for tozalash in (False, True):
    n, _ = skanerla(hujjat, olcham=OLCHOV, tozalash=tozalash)
    a, t, f1 = sifat(n)
    qatorlar.append({"MORPH_CLOSE": "bor" if tozalash else "yo'q",
                     "aniqlik %": a, "to'liqlik %": t, "F1 %": f1})
show(pd.DataFrame(qatorlar))

qatorlar = []
for blok in (15, 31, 51):
    for C in (5, 10, 15, 20):
        n, _ = skanerla(hujjat, blockSize=blok, C=C, olcham=OLCHOV)
        a, t, f1 = sifat(n)
        qatorlar.append({"blockSize": blok, "C": C, "aniqlik %": a, "to'liqlik %": t, "F1 %": f1})
jadval = pd.DataFrame(qatorlar)
show(jadval.sort_values("F1 %", ascending=False).head(8))
eng = jadval.loc[jadval["F1 %"].idxmax()]
print(f"eng yaxshi: blockSize={int(eng['blockSize'])}, C={int(eng['C'])}, F1={eng['F1 %']}%")

def buzilgan(rasm, tur):
    if tur == "asl":
        return rasm
    if tur == "kichraytirilgan (0.5x)":
        return cv2.resize(rasm, None, fx=0.5, fy=0.5, interpolation=cv2.INTER_AREA)
    if tur == "burilgan 10°":
        M = cv2.getRotationMatrix2D((rasm.shape[1] / 2, rasm.shape[0] / 2), 10, 1.0)
        return cv2.warpAffine(rasm, M, (rasm.shape[1], rasm.shape[0]), borderValue=(60, 60, 60))
    if tur == "shovqinli":
        shovqin = np.random.default_rng(1).normal(0, 12, rasm.shape)
        return np.clip(rasm + shovqin, 0, 255).astype(np.uint8)
    if tur == "qorong'i (0.5x)":
        return np.clip(rasm * 0.5, 0, 255).astype(np.uint8)
    if tur == "xira (blur 9)":
        return cv2.GaussianBlur(rasm, (9, 9), 0)
    if tur == "varaqsiz (faqat fon)":
        return cv2.resize(cv2.imread(str(RASM / "qurilish_kichik.jpg")), (800, 1000))
    raise ValueError(tur)

TURLAR = ["asl", "kichraytirilgan (0.5x)", "burilgan 10°", "shovqinli", "qorong'i (0.5x)",
          "xira (blur 9)", "varaqsiz (faqat fon)"]
qatorlar = []
for tur in TURLAR:
    n, inf = skanerla(buzilgan(hujjat, tur), olcham=OLCHOV)
    a, t, f1 = sifat(n)
    qatorlar.append({"kirish": tur, "burchak topildimi": n is not None,
                     "o'lcham": str(inf.get("o'lcham", "-")), "F1 %": f1 if n is not None else None})
show(pd.DataFrame(qatorlar))

import time
t0 = time.perf_counter()
for _ in range(20):
    skanerla(hujjat)
print(f"bitta hujjat: {(time.perf_counter() - t0) / 20 * 1000:.1f} ms")

for kenglik in (400, 600, 1000):
    t0 = time.perf_counter()
    for _ in range(10):
        burchaklarni_top(hujjat, ishchi_kenglik=kenglik)
    print(f"burchak topish (ishchi kenglik {kenglik}): {(time.perf_counter() - t0) / 10 * 1000:.1f} ms")

def burchaklarni_top(rasm, ishchi_kenglik=600): ...     # None qaytarishi mumkin
def burchaklarni_tartibla(p): ...                       # doim 4x2, aniq tartibda
def chiqish_olchami(t): ...                             # (w, h)
def skanerla(rasm, blockSize=31, C=15, olcham=None, tozalash=False): ...