{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Görüntü İşleme ve OpenCV — 4. Hafta",
    "",
    "**Yapay Zeka Uygulamaları · Öğr. Gör. Erdi YALÇIN**",
    "",
    "Bu notebook ders notundaki bütün OpenCV örneklerini içerir ve **internet kapalı** çalışır:",
    "örnek görüntüler `skimage.data` ile birlikte gelir, hiçbir veri seti eklemeniz gerekmez.",
    "",
    "**Nasıl çalıştırılır:** her hücreye tıklayıp `Shift + Enter`. Sırayla gidin, hücreler",
    "birbirinin değişkenlerini kullanıyor.",
    "",
    "**GPU gerekmez** — bu notebook tamamen CPU'da çalışır. GPU'yu CNN notebook'unda açacağız.",
    "",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 · Kurulum kontrolü"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2",
    "import numpy as np",
    "import matplotlib.pyplot as plt",
    "from skimage import data",
    "",
    "print(\"OpenCV surumu:\", cv2.__version__)",
    "print(\"NumPy  surumu:\", np.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 · Dersin boyunca kullanacağımız görüntüler",
    "",
    "`skimage.data` kütüphaneyle birlikte gelen örnek görüntüleri verir. İnternet gerekmez,",
    "herkeste aynıdır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "astro   = data.astronaut()   # (512, 512, 3) renkli - icinde bir YUZ var",
    "kamera  = data.camera()      # (512, 512)    gri    - klasik test goruntusu",
    "paralar = data.coins()       # (303, 384)    gri    - 24 madeni para",
    "sayfa   = data.page()        # (191, 384)    gri    - ISIK ESIT DEGIL",
    "kedi    = data.chelsea()     # (300, 451, 3) renkli - bir kedi",
    "",
    "for ad, g in [(\"astronaut\", astro), (\"camera\", kamera), (\"coins\", paralar),",
    "              (\"page\", sayfa), (\"chelsea\", kedi)]:",
    "    print(f\"{ad:10s} {str(g.shape):16s} {g.dtype}  min={g.min():3d} max={g.max():3d}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`shape` uzunluğu **2** ise gri, **3** ise renkli. `page` görüntüsünün en koyu değeri 20,",
    "en parlağı 227 — ne tam siyahı ne tam beyazı var. Bu, ışığın eşit olmadığının işareti;",
    "4. bölümde global eşiklemenin neden çöktüğünü bu görüntüyle göreceğiz.",
    "",
    "**Önemli:** `skimage` görüntüleri **RGB**, `cv2.imread` ise **BGR** döner."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 · Yardımcı `goster()` fonksiyonu — dersin geri kalanında hep bunu kullanacağız"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def goster(goruntuler, basliklar, satir=1, buyukluk=3.6):",
    "    \"\"\"Birden fazla goruntuyu yan yana cizer.\"\"\"",
    "    n = len(goruntuler)",
    "    sutun = int(np.ceil(n / satir))",
    "    plt.figure(figsize=(buyukluk * sutun, buyukluk * satir * 0.95))",
    "    for i, (g, b) in enumerate(zip(goruntuler, basliklar), start=1):",
    "        plt.subplot(satir, sutun, i)",
    "        if g.ndim == 2:                      # gri",
    "            plt.imshow(g, cmap=\"gray\", vmin=0, vmax=255)",
    "        else:                                # renkli: RGB bekliyoruz",
    "            plt.imshow(g)",
    "        plt.title(b, fontsize=10)",
    "        plt.axis(\"off\")",
    "    plt.tight_layout()",
    "    plt.show()",
    "",
    "goster([astro, kedi], [\"astronaut (RGB)\", \"chelsea (RGB)\"])",
    "goster([kamera, paralar, sayfa], [\"camera\", \"coins\", \"page\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Neden `vmin=0, vmax=255`?** Matplotlib gri görüntüyü çizerken varsayılan olarak kendi",
    "içindeki en küçük değeri siyah, en büyüğü beyaz kabul eder — yani görüntüyü farkında olmadan",
    "kontrastlar. Bu iki parametreyi vermezseniz uyguladığınız filtrenin etkisini yanlış değerlendirirsiniz."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 · Piksel okuma ve yazma — görüntü bir sayı tablosudur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gri = cv2.cvtColor(cv2.cvtColor(astro, cv2.COLOR_RGB2BGR), cv2.COLOR_BGR2GRAY)",
    "",
    "print(gri.shape)         # (512, 512)      -> (yukseklik, genislik)",
    "print(astro.shape)       # (512, 512, 3)   -> ucuncu boyut kanal",
    "print(gri.dtype)         # uint8           -> 0..255 arasi tam sayi",
    "",
    "print(\"Tek piksel (gri) :\", gri[250, 300])",
    "print(\"Tek piksel (RGB) :\", astro[250, 300])",
    "",
    "# 8x8'lik bir pencerenin GERCEK SAYILARI",
    "print(\"\\n8x8 pencere:\")",
    "print(gri[250:258, 300:308])",
    "",
    "# Piksel yazmak",
    "kopya = gri.copy()",
    "kopya[0:40, 0:40] = 255        # sol ust koseyi bembeyaz yap",
    "kopya[100:105, :] = 0          # bes satirlik siyah cizgi",
    "goster([gri, kopya], [\"orijinal\", \"piksel yazilmis\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**En sık yapılan iki hata:**",
    "- `gri[x, y]` yazmak. Doğrusu `gri[y, x]` — numpy önce satırı sorar.",
    "- `uint8` taşması: `200 + 100` işlemi 300 değil **44** verir. Parlaklık eklerken `cv2.add` kullanın."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5 · Kanallar, gri tonlama ve BGR tuzağı"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bgr = cv2.cvtColor(astro, cv2.COLOR_RGB2BGR)   # skimage RGB verdi, cv2 BGR bekliyor",
    "",
    "# --- Kanallari ayirmak ---",
    "b, g, r = cv2.split(bgr)",
    "",
    "# --- Gri tonlama: 0.299*R + 0.587*G + 0.114*B ---",
    "gri_a = cv2.cvtColor(bgr, cv2.COLOR_BGR2GRAY)",
    "",
    "# --- BGR TUZAGI: cevirmeyi unutursaniz bu cikar ---",
    "goster([astro, bgr, gri_a],",
    "       [\"DOGRU: cvtColor(BGR2RGB) sonrasi\",",
    "        \"YANLIS: BGR'yi RGB sanmak\",",
    "        \"gri tonlama\"])",
    "",
    "goster([r, g, b], [\"kirmizi kanal\", \"yesil kanal\", \"mavi kanal\"])",
    "",
    "# Tek kanali sifirlamak",
    "mavisiz = bgr.copy()",
    "mavisiz[:, :, 0] = 0",
    "goster([astro, cv2.cvtColor(mavisiz, cv2.COLOR_BGR2RGB)], [\"orijinal\", \"mavi kanal sifirlanmis\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6 · Kırpma (ROI), yeniden boyutlandırma, döndürme"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "h, w = kamera.shape",
    "",
    "# --- Kirpma: sadece numpy dilimlemesi. [y0:y1, x0:x1] ---",
    "yuz = astro[30:230, 150:350].copy()     # .copy() SART: dilim ayni bellege bakar",
    "print(\"Kirpilmis:\", yuz.shape)",
    "",
    "# --- resize: boyut (GENISLIK, YUKSEKLIK) sirasinda! shape'in TERSI ---",
    "kucuk = cv2.resize(kamera, (w // 4, h // 4), interpolation=cv2.INTER_AREA)",
    "print(kamera.shape, \"->\", kucuk.shape)",
    "",
    "geri_komsu = cv2.resize(kucuk, (w, h), interpolation=cv2.INTER_NEAREST)",
    "geri_dogru = cv2.resize(kucuk, (w, h), interpolation=cv2.INTER_LINEAR)",
    "geri_kubik = cv2.resize(kucuk, (w, h), interpolation=cv2.INTER_CUBIC)",
    "",
    "goster([kamera, geri_komsu, geri_dogru, geri_kubik],",
    "       [\"orijinal\", \"NEAREST (kareli)\", \"LINEAR (yumusak)\", \"CUBIC (en keskin)\"])",
    "",
    "# --- Cevirme ve dondurme ---",
    "yatay = cv2.flip(kamera, 1)",
    "sag90 = cv2.rotate(kamera, cv2.ROTATE_90_CLOCKWISE)",
    "",
    "M = cv2.getRotationMatrix2D((w // 2, h // 2), angle=23, scale=1.0)",
    "donuk = cv2.warpAffine(kamera, M, (w, h), borderValue=0)",
    "",
    "T = np.float32([[1, 0, 40], [0, 1, 15]])        # 40 saga, 15 asagi",
    "otelenmis = cv2.warpAffine(kamera, T, (w, h))",
    "",
    "goster([astro, yuz], [\"orijinal\", \"kirpilmis yuz (ROI)\"])",
    "goster([kamera, yatay, sag90, donuk, otelenmis],",
    "       [\"orijinal\", \"flip(1)\", \"rotate 90\", \"warpAffine 23 derece\", \"oteleme (40,15)\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Kural:** küçültürken `INTER_AREA`, büyütürken `INTER_CUBIC`.",
    "`INTER_NEAREST` sadece maske ve etiket görüntülerinde.",
    "",
    "Bu dört dönüşüm CNN eğitirken **veri artırma** adıyla geri gelecek."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7 · Görüntünün üstüne çizim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuval = cv2.cvtColor(kamera, cv2.COLOR_GRAY2BGR)   # gri -> 3 kanal",
    "",
    "cv2.line(tuval, (20, 20), (480, 90), (0, 0, 255), 2)             # kirmizi (BGR!)",
    "cv2.rectangle(tuval, (150, 120), (330, 300), (0, 255, 0), 3)     # yesil cerceve",
    "cv2.rectangle(tuval, (360, 360), (470, 470), (255, 200, 0), -1)  # -1 = ICINI DOLDUR",
    "cv2.circle(tuval, (256, 256), 60, (0, 255, 255), 2)",
    "cv2.putText(tuval, \"kamera\", (24, 500), cv2.FONT_HERSHEY_SIMPLEX,",
    "            1.0, (255, 255, 255), 2, cv2.LINE_AA)",
    "",
    "goster([cv2.cvtColor(tuval, cv2.COLOR_BGR2RGB)], [\"uzerine cizim\"], buyukluk=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8 · Histogram, parlaklık, kontrast"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# --- Histogram ---",
    "hist = cv2.calcHist([sayfa], [0], None, [256], [0, 256])",
    "plt.figure(figsize=(7, 2.6))",
    "plt.plot(hist, color=\"#275d8c\")",
    "plt.fill_between(range(256), hist.ravel(), color=\"#275d8c\", alpha=.18)",
    "plt.title(\"page goruntusunun histogrami\"); plt.xlabel(\"parlaklik\"); plt.ylabel(\"piksel sayisi\")",
    "plt.xlim(0, 255); plt.show()",
    "",
    "# --- Parlaklik ve kontrast: yeni = alpha*eski + beta ---",
    "daha_parlak   = cv2.convertScaleAbs(sayfa, alpha=1.0, beta=45)",
    "daha_kontrast = cv2.convertScaleAbs(sayfa, alpha=1.8, beta=-60)",
    "",
    "# TASMA UYARISI",
    "guvenli   = cv2.add(sayfa, 45)        # 255'te durur  (DOGRU)",
    "tehlikeli = sayfa + 45                # 256'da sifira doner (YANLIS)",
    "goster([guvenli, tehlikeli], [\"cv2.add (dogru)\", \"sayfa + 45 (tasma!)\"])",
    "",
    "# --- Histogram esitleme ve CLAHE ---",
    "esit  = cv2.equalizeHist(sayfa)",
    "clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))",
    "yerel = clahe.apply(sayfa)",
    "",
    "goster([sayfa, daha_parlak, daha_kontrast, esit, yerel],",
    "       [\"orijinal\", \"beta=+45\", \"alpha=1.8\", \"equalizeHist\", \"CLAHE\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`equalizeHist` görüntünün tamamına tek bir düzeltme uygular; **CLAHE** 8x8 karelere bölüp",
    "her kareyi ayrı düzeltir. Işık eşitsizse neredeyse her zaman CLAHE tercih edilir."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9 · Eşikleme — global eşiğin çöktüğü yer",
    "",
    "`page` görüntüsünün bir köşesi karanlık. Hangi eşiği verirseniz verin sayfanın bir yarısını",
    "kaybediyorsunuz. Çözüm: uyarlamalı eşikleme."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "elle_t = 127",
    "_,   elle  = cv2.threshold(sayfa, elle_t, 255, cv2.THRESH_BINARY)",
    "",
    "# THRESH_OTSU kullanirken esige 0 yazilir; OpenCV esigi KENDISI bulur ve donus degerinde soyler.",
    "ot_t, otsu = cv2.threshold(sayfa, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)",
    "print(\"Otsu'nun buldugu esik:\", ot_t)",
    "",
    "uyarlamali = cv2.adaptiveThreshold(",
    "    sayfa, 255,",
    "    cv2.ADAPTIVE_THRESH_GAUSSIAN_C,",
    "    cv2.THRESH_BINARY,",
    "    blockSize=25,       # TEK SAYI olmak ZORUNDA",
    "    C=7                 # ortalamadan cikarilacak sabit",
    ")",
    "",
    "goster([sayfa, elle, otsu, uyarlamali],",
    "       [\"orijinal (isik esitsiz)\", f\"elle: {elle_t}\", f\"Otsu: {ot_t:.0f}\", \"adaptiveThreshold\"])",
    "",
    "# Esik taramasi: hicbir global esik ise yaramiyor",
    "denemeler = [cv2.threshold(sayfa, t, 255, cv2.THRESH_BINARY)[1] for t in (80, 110, 140, 170)]",
    "goster(denemeler, [f\"esik={t}\" for t in (80, 110, 140, 170)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Karar ağacı:**",
    "1. Işık her yerde aynı mı? → **Otsu**.",
    "2. Işık eşitsiz mi? → **adaptiveThreshold**.",
    "3. Nesne renginden ayrılıyor mu? → **HSV + inRange** (13. bölüm).",
    "4. Hiçbiri olmuyor mu? → Problem eşikleme problemi değil; CNN'e gidin."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10 · Evrişim ve kendi çekirdekleriniz — `filter2D`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cekirdekler = {",
    "    \"birim\":      np.array([[0, 0, 0], [0, 1, 0], [0, 0, 0]], np.float32),",
    "    \"ortalama\":   np.ones((3, 3), np.float32) / 9,          # 9'a BOLDUK",
    "    \"gauss\":      np.array([[1, 2, 1], [2, 4, 2], [1, 2, 1]], np.float32) / 16,",
    "    \"keskin\":     np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]], np.float32),",
    "    \"sobel_x\":    np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], np.float32),",
    "    \"laplacian\":  np.array([[0, 1, 0], [1, -4, 1], [0, 1, 0]], np.float32),",
    "    \"kabartma\":   np.array([[-2, -1, 0], [-1, 1, 1], [0, 1, 2]], np.float32),",
    "}",
    "",
    "sonuclar, adlar = [kamera], [\"orijinal\"]",
    "for ad, cek in cekirdekler.items():",
    "    sonuclar.append(cv2.filter2D(kamera, -1, cek))",
    "    adlar.append(f\"{ad}  (toplam={cek.sum():.0f})\")",
    "goster(sonuclar, adlar, satir=2)",
    "",
    "# Buyuk cekirdek daha cok bulaniklastirir",
    "cok_bulanik = cv2.filter2D(kamera, -1, np.ones((15, 15), np.float32) / 225)",
    "goster([kamera, cv2.filter2D(kamera, -1, cekirdekler[\"ortalama\"]), cok_bulanik],",
    "       [\"orijinal\", \"3x3 ortalama\", \"15x15 ortalama\"])",
    "",
    "# BOLMEYI UNUTURSANIZ: goruntu yanar",
    "yanmis = cv2.filter2D(kamera, -1, np.ones((3, 3), np.float32))",
    "goster([cv2.filter2D(kamera, -1, cekirdekler[\"ortalama\"]), yanmis],",
    "       [\"9'a bolunmus (dogru)\", \"bolunmemis (toplam=9, yaniyor)\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Çekirdeğin toplamına bakarak sonucu tahmin edin:**",
    "- Toplam **1** → parlaklık korunur (bulanıklaştırma, keskinleştirme).",
    "- Toplam **0** → düz alanlar siyaha iner, sadece kenarlar kalır.",
    "- Toplam > 1 → görüntü parlar. Toplam < 0 → kararır ve negatife döner.",
    "",
    "**`ddepth=-1` tuzağı:** kenar bulurken çıktı `uint8` olursa eksi değerler sıfıra kırpılır.",
    "Doğru yazım `cv2.filter2D(gri, cv2.CV_32F, cek)` + `cv2.convertScaleAbs(...)`.",
    "`cv2.Sobel` bunu zaten doğru yapar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11 · Gürültü ve dört bulanıklaştırma — hangisi kazanıyor?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rng = np.random.default_rng(42)          # tohum: herkeste ayni sonuc",
    "",
    "# --- Gauss gurultusu ---",
    "gurultulu = np.clip(kamera.astype(np.int16) + rng.normal(0, 18, kamera.shape), 0, 255).astype(np.uint8)",
    "",
    "# --- Tuz-biber gurultusu ---",
    "tuzbiber = kamera.copy()",
    "maske = rng.random(kamera.shape)",
    "tuzbiber[maske < 0.04] = 0        # biber (siyah)",
    "tuzbiber[maske > 0.96] = 255      # tuz   (beyaz)",
    "",
    "def dort_filtre(g):",
    "    return [",
    "        cv2.blur(g, (5, 5)),",
    "        cv2.GaussianBlur(g, (5, 5), 0),       # 0 -> sigma'yi ksize'dan hesapla",
    "        cv2.medianBlur(g, 5),                 # ksize TEK SAYI",
    "        cv2.bilateralFilter(g, 9, 75, 75),",
    "    ]",
    "",
    "adlar_f = [\"blur\", \"GaussianBlur\", \"medianBlur\", \"bilateralFilter\"]",
    "goster([tuzbiber] + dort_filtre(tuzbiber), [\"TUZ-BIBER\"] + adlar_f)",
    "goster([gurultulu] + dort_filtre(gurultulu), [\"GAUSS\"] + adlar_f)",
    "",
    "def uzaklik(a, b):",
    "    return np.sqrt(np.mean((a.astype(np.float64) - b.astype(np.float64)) ** 2))",
    "",
    "for ad, veri in [(\"tuz-biber\", tuzbiber), (\"gauss\", gurultulu)]:",
    "    print(f\"\\n--- {ad} --- (kucuk = iyi)\")",
    "    print(f\"{'gurultulu hali':18s} {uzaklik(veri, kamera):6.2f}\")",
    "    for a, s in zip(adlar_f, dort_filtre(veri)):",
    "        print(f\"{a:18s} {uzaklik(s, kamera):6.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tuz-biberde `medianBlur` kazanır** — ortanca, tek tük uç değerleri hiç hesaba katmaz",
    "(2. haftanın ortalama/ortanca dersi, bu kez görüntüde).",
    "**Gauss gürültüsünde `GaussianBlur` kazanır.**",
    "",
    "`bilateralFilter` tuz-biberde kaybeder: beyaz noktayı \"korunması gereken bir kenar\" sanır.",
    "Bir filtrenin gücü aynı anda zayıflığıdır."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 12 · Kenar bulma: Sobel, Laplacian, Canny"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# --- 1) ONCE BULANIKLASTIR. Bu adimi atlamak en sik hata. ---",
    "bulanik = cv2.GaussianBlur(kamera, (5, 5), 1.4)",
    "",
    "# --- 2) Sobel: CV_64F sart, yoksa eksi turevler kirpilir ---",
    "gx = cv2.Sobel(bulanik, cv2.CV_64F, 1, 0, ksize=3)    # dikey kenarlar",
    "gy = cv2.Sobel(bulanik, cv2.CV_64F, 0, 1, ksize=3)    # yatay kenarlar",
    "sobel_x = cv2.convertScaleAbs(gx)",
    "sobel_y = cv2.convertScaleAbs(gy)",
    "",
    "buyukluk = cv2.magnitude(gx, gy)",
    "aci      = cv2.phase(gx, gy, angleInDegrees=True)     # kenarin YONU",
    "buyukluk = cv2.normalize(buyukluk, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)",
    "",
    "# --- 3) Laplacian: yonsuz ---",
    "lap = cv2.convertScaleAbs(cv2.Laplacian(bulanik, cv2.CV_64F, ksize=3))",
    "",
    "# --- 4) Canny ---",
    "kenar = cv2.Canny(bulanik, 40, 110)",
    "",
    "goster([kamera, sobel_x, sobel_y, buyukluk, lap, kenar],",
    "       [\"orijinal\", \"Sobel X\", \"Sobel Y\", \"buyukluk\", \"Laplacian\", \"Canny(40,110)\"], satir=2)",
    "",
    "# --- Esikleri Otsu'dan turetmek ---",
    "ot, _ = cv2.threshold(bulanik, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)",
    "oto = cv2.Canny(bulanik, int(ot * 0.5), int(ot))",
    "print(f\"Otsu: {ot:.0f}  ->  Canny({ot*0.5:.0f}, {ot:.0f})\")",
    "",
    "# --- Esik taramasi ---",
    "denemeler, adlar2 = [], []",
    "for alt, ust in [(10, 40), (40, 110), (80, 180), (150, 250)]:",
    "    denemeler.append(cv2.Canny(bulanik, alt, ust))",
    "    adlar2.append(f\"Canny({alt}, {ust})\")",
    "goster(denemeler, adlar2)",
    "",
    "# --- Bulaniklastirmazsak ne olur? ---",
    "goster([cv2.Canny(kamera, 40, 110), kenar],",
    "       [\"bulaniklastirmadan (gurultu kenar sanildi)\", \"once GaussianBlur (dogru)\"])",
    "",
    "# --- Kenar yuzdesi: sagliklı sonuc %1-6 arasidir ---",
    "print(\"Kenar pikseli orani: %.2f%%\" % (100 * (kenar > 0).mean()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Canny'nin dört adımı:** bulanıklaştır → türev al → tepeyi incelt (non-maximum suppression) →",
    "iki eşik + bağlama (hysteresis).",
    "",
    "**Pratik kural:** üst eşik, alt eşiğin 2–3 katı. `Canny(gri, 50, 150)` ile başlayın.",
    "Sonuç dağınıksa ikisini yükseltin; kenarlar kopuksa alt eşiği düşürün."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 13 · Morfoloji: ikili görüntüyü temizlemek"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "_, ikili = cv2.threshold(paralar, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)",
    "",
    "# Cekirdek sekli ONEMLI:",
    "#   MORPH_RECT    -> kare, hizli",
    "#   MORPH_ELLIPSE -> daire, yuvarlak nesneler icin DOGAL  <- genelde bunu secin",
    "#   MORPH_CROSS   -> arti, cizgi ve iskelet islerinde",
    "cek = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))",
    "",
    "erozyon  = cv2.erode(ikili, cek, iterations=1)",
    "genislet = cv2.dilate(ikili, cek, iterations=1)",
    "acma     = cv2.morphologyEx(ikili, cv2.MORPH_OPEN,     cek)",
    "kapama   = cv2.morphologyEx(ikili, cv2.MORPH_CLOSE,    cek)",
    "gradyan  = cv2.morphologyEx(ikili, cv2.MORPH_GRADIENT, cek)",
    "",
    "goster([ikili, erozyon, genislet, acma, kapama, gradyan],",
    "       [\"esiklenmis\", \"erode\", \"dilate\", \"OPEN\", \"CLOSE\", \"GRADIENT\"], satir=2)",
    "",
    "# Kucuk parlak / koyu detaylari cekip cikarmak",
    "tophat   = cv2.morphologyEx(paralar, cv2.MORPH_TOPHAT,   cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (31, 31)))",
    "blackhat = cv2.morphologyEx(paralar, cv2.MORPH_BLACKHAT, cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (31, 31)))",
    "goster([paralar, tophat, blackhat], [\"orijinal\", \"TOPHAT (kucuk parlaklar)\", \"BLACKHAT (kucuk koyular)\"])",
    "",
    "# Pratikte en cok kullanilan sira: once ACMA, sonra KAPAMA",
    "temiz = cv2.morphologyEx(ikili, cv2.MORPH_OPEN,  cek)",
    "temiz = cv2.morphologyEx(temiz, cv2.MORPH_CLOSE, cek)",
    "goster([ikili, temiz], [\"ham esikleme\", \"acma + kapama\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Hatırlama yolu:** **A**çma = beyazı **a**zaltır (beyaz lekeleri siler).",
    "**K**apama = siyahı **k**apatır (siyah delikleri doldurur).",
    "",
    "**Çekirdek boyutu kuralı:** silmek istediğiniz gürültüden büyük, korumak istediğiniz nesneden küçük."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 14 · Kontur bulma ve nesne sayma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd",
    "",
    "gri_p = paralar.copy()",
    "bulanik_p = cv2.GaussianBlur(gri_p, (5, 5), 1.2)",
    "",
    "esik, ikili_p = cv2.threshold(bulanik_p, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)",
    "print(\"Otsu esigi:\", esik)",
    "",
    "cek   = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))",
    "temiz = cv2.morphologyEx(ikili_p, cv2.MORPH_OPEN,  cek, iterations=2)",
    "temiz = cv2.morphologyEx(temiz,   cv2.MORPH_CLOSE, cek, iterations=2)",
    "",
    "# RETR_EXTERNAL -> sadece EN DIS sinirlar",
    "# CHAIN_APPROX_SIMPLE -> sadece kose noktalarini sakla",
    "konturlar, hiyerarsi = cv2.findContours(temiz, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)",
    "print(\"Ham kontur sayisi:\", len(konturlar))",
    "",
    "# ALANA GORE SUZ. Bu adimi atlamayin!",
    "EN_AZ_ALAN = 150",
    "gercek = [k for k in konturlar if cv2.contourArea(k) > EN_AZ_ALAN]",
    "print(\"Suzuldukten sonra:\", len(gercek))",
    "",
    "tuval = cv2.cvtColor(gri_p, cv2.COLOR_GRAY2BGR)",
    "cv2.drawContours(tuval, gercek, -1, (0, 255, 0), 2)",
    "for i, k in enumerate(gercek, start=1):",
    "    x, y, w_, h_ = cv2.boundingRect(k)",
    "    M = cv2.moments(k)",
    "    cx, cy = int(M[\"m10\"] / M[\"m00\"]), int(M[\"m01\"] / M[\"m00\"])",
    "    cv2.circle(tuval, (cx, cy), 3, (0, 0, 255), -1)",
    "    cv2.putText(tuval, str(i), (x, y - 5), cv2.FONT_HERSHEY_SIMPLEX,",
    "                0.5, (255, 255, 0), 1, cv2.LINE_AA)",
    "",
    "goster([gri_p, ikili_p, temiz, cv2.cvtColor(tuval, cv2.COLOR_BGR2RGB)],",
    "       [\"orijinal\", \"Otsu\", \"temizlenmis\", f\"{len(gercek)} nesne bulundu\"], satir=2)",
    "",
    "# Her nesnenin olculeri",
    "satirlar = []",
    "for i, k in enumerate(gercek, start=1):",
    "    alan  = cv2.contourArea(k)",
    "    cevre = cv2.arcLength(k, True)",
    "    x, y, w_, h_ = cv2.boundingRect(k)",
    "    dairelik = 4 * np.pi * alan / (cevre ** 2) if cevre else 0",
    "    satirlar.append({\"no\": i, \"alan\": round(alan), \"cevre\": round(cevre, 1),",
    "                     \"en\": w_, \"boy\": h_, \"dairelik\": round(dairelik, 3)})",
    "print(pd.DataFrame(satirlar).to_string(index=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**24 para var ama daha azını bulduk. Neden?** Birbirine değen paralar eşiklemeden sonra",
    "tek bir beyaz leke oluyor ve `findContours` onları tek nesne sayıyor. Alanı normalin iki katı",
    "olan bir kontur bunun işaretidir.",
    "",
    "**Çözümler:** erozyonu artırmak · alan kontrolü · `cv2.watershed` (doğru çözüm) ·",
    "derin öğrenme tabanlı nesne tespiti (10. hafta)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 15 · Şekil tanıma: köşe sayarak"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sekil_adi(kontur):",
    "    cevre = cv2.arcLength(kontur, True)",
    "    # epsilon: cevrenin %2'si kadar sapmaya izin ver",
    "    kose = cv2.approxPolyDP(kontur, 0.02 * cevre, True)",
    "    n = len(kose)",
    "    if n == 3:",
    "        return \"ucgen\"",
    "    if n == 4:",
    "        x, y, w_, h_ = cv2.boundingRect(kose)",
    "        return \"kare\" if 0.93 <= w_ / h_ <= 1.07 else \"dikdortgen\"",
    "    if n == 5:",
    "        return \"besgen\"",
    "    alan = cv2.contourArea(kontur)",
    "    dairelik = 4 * np.pi * alan / (cevre ** 2) if cevre else 0",
    "    return \"daire\" if dairelik > 0.80 else f\"duzensiz ({n} kose)\"",
    "",
    "for i, k in enumerate(gercek[:10], start=1):",
    "    print(f\"{i:2d}. nesne: {sekil_adi(k):16s} alan={cv2.contourArea(k):7.0f}\")",
    "",
    "# epsilon'un etkisini gorelim",
    "en_buyuk = max(gercek, key=cv2.contourArea)",
    "for eps in (0.001, 0.01, 0.05, 0.15):",
    "    kose = cv2.approxPolyDP(en_buyuk, eps * cv2.arcLength(en_buyuk, True), True)",
    "    print(f\"epsilon={eps:<6} -> {len(kose):3d} kose\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 16 · HSV ile renge göre nesne bulma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bgr_k = cv2.cvtColor(kedi, cv2.COLOR_RGB2BGR)",
    "hsv   = cv2.cvtColor(bgr_k, cv2.COLOR_BGR2HSV)",
    "",
    "# OpenCV HSV araliklari:  H 0-179   S 0-255   V 0-255",
    "# KIRMIZI cemberin BASINDA ve SONUNDA: iki aralik gerekir",
    "alt1, ust1 = np.array([  0, 110,  70]), np.array([ 10, 255, 255])",
    "alt2, ust2 = np.array([170, 110,  70]), np.array([179, 255, 255])",
    "maske_kirmizi = cv2.bitwise_or(cv2.inRange(hsv, alt1, ust1),",
    "                               cv2.inRange(hsv, alt2, ust2))",
    "",
    "maske_mavi  = cv2.inRange(hsv, np.array([100, 100,  50]), np.array([130, 255, 255]))",
    "maske_yesil = cv2.inRange(hsv, np.array([ 35,  70,  50]), np.array([ 85, 255, 255]))",
    "maske_sari  = cv2.inRange(hsv, np.array([ 20, 100, 100]), np.array([ 35, 255, 255]))",
    "",
    "# Maskeyi morfolojiyle temizle",
    "cek5 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))",
    "maske_sari = cv2.morphologyEx(maske_sari, cv2.MORPH_OPEN,  cek5)",
    "maske_sari = cv2.morphologyEx(maske_sari, cv2.MORPH_CLOSE, cek5)",
    "",
    "sadece_sari = cv2.bitwise_and(bgr_k, bgr_k, mask=maske_sari)",
    "",
    "goster([kedi, maske_kirmizi, maske_mavi, maske_sari,",
    "        cv2.cvtColor(sadece_sari, cv2.COLOR_BGR2RGB)],",
    "       [\"orijinal\", \"kirmizi maske\", \"mavi maske\", \"sari maske (temiz)\", \"maske uygulanmis\"])",
    "",
    "# HSV degerini OLCUN, tahmin etmeyin:",
    "print(\"Bir pikselin HSV degeri:\", hsv[150, 220])",
    "",
    "kont, _ = cv2.findContours(maske_sari, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)",
    "print(\"Sari bolge sayisi:\", len([k for k in kont if cv2.contourArea(k) > 200]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**H için ±10 pay yeter; S ve V için geniş aralık verin** (gölge ve ışık bunları değiştirir).",
    "**Kırmızı her zaman iki aralık ister:** 0–10 ve 170–179."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 17 · Haar cascade ile yüz ve göz bulma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os",
    "",
    "yol = cv2.data.haarcascades",
    "print(\"Hazir modeller:\", yol)",
    "print([f for f in os.listdir(yol) if \"frontalface\" in f or \"eye\" in f][:6])",
    "",
    "yuz_bulucu = cv2.CascadeClassifier(yol + \"haarcascade_frontalface_default.xml\")",
    "goz_bulucu = cv2.CascadeClassifier(yol + \"haarcascade_eye.xml\")",
    "assert not yuz_bulucu.empty(), \"Model yuklenemedi - yolu kontrol edin\"",
    "",
    "bgr_a = cv2.cvtColor(astro, cv2.COLOR_RGB2BGR)",
    "gri_h = cv2.equalizeHist(cv2.cvtColor(bgr_a, cv2.COLOR_BGR2GRAY))",
    "",
    "yuzler = yuz_bulucu.detectMultiScale(",
    "    gri_h,",
    "    scaleFactor=1.08,    # kucuk deger = yavas ama titiz",
    "    minNeighbors=5,      # buyuk deger = daha az yanlis alarm",
    "    minSize=(40, 40)",
    ")",
    "print(\"Bulunan yuz sayisi:\", len(yuzler))",
    "",
    "tuval_y = bgr_a.copy()",
    "for (x, y, w_, h_) in yuzler:",
    "    cv2.rectangle(tuval_y, (x, y), (x + w_, y + h_), (0, 255, 0), 2)",
    "    # Gozleri SADECE yuzun icinde ara",
    "    roi_gri  = gri_h[y:y + h_, x:x + w_]",
    "    roi_renk = tuval_y[y:y + h_, x:x + w_]",
    "    for (gx_, gy_, gw, gh) in goz_bulucu.detectMultiScale(roi_gri, 1.1, 6):",
    "        cv2.rectangle(roi_renk, (gx_, gy_), (gx_ + gw, gy_ + gh), (255, 200, 0), 2)",
    "",
    "goster([astro, cv2.cvtColor(tuval_y, cv2.COLOR_BGR2RGB)],",
    "       [\"orijinal\", f\"{len(yuzler)} yuz bulundu\"], buyukluk=4.5)",
    "",
    "# Parametrelerin etkisi",
    "for sf, mn in [(1.02, 3), (1.08, 5), (1.3, 8)]:",
    "    n = len(yuz_bulucu.detectMultiScale(gri_h, sf, mn))",
    "    print(f\"scaleFactor={sf}, minNeighbors={mn}  ->  {n} yuz\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Hiç yüz bulamadıysa:** `scaleFactor`'ı 1.05'e düşürün, `minNeighbors`'ı 3'e indirin.",
    "**Olmayan yerde yüz görüyorsa:** `minNeighbors`'ı 8–10'a çıkarın.",
    "",
    "**Haar'ın sınırları:** yalnızca karşıdan bakan yüzler. Yana dönmüş baş, maske, zayıf ışıkta başarısız.",
    "Ayrıca **kimin** yüzü olduğunu söylemez. Bugün ciddi işlerde yerini derin öğrenme aldı."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 18 · Şablon eşleme"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sablon = kamera[200:280, 190:270]          # kameramanin yuz bolgesi (80x80)",
    "th, tw = sablon.shape",
    "",
    "sonuc = cv2.matchTemplate(kamera, sablon, cv2.TM_CCOEFF_NORMED)",
    "en_az, en_cok, yer_az, yer_cok = cv2.minMaxLoc(sonuc)",
    "print(f\"En iyi benzerlik: {en_cok:.3f}  konum: {yer_cok}\")",
    "",
    "tuval_s = cv2.cvtColor(kamera, cv2.COLOR_GRAY2BGR)",
    "cv2.rectangle(tuval_s, yer_cok, (yer_cok[0] + tw, yer_cok[1] + th), (0, 255, 0), 2)",
    "goster([sablon, sonuc, cv2.cvtColor(tuval_s, cv2.COLOR_BGR2RGB)],",
    "       [\"aranan sablon\", \"benzerlik haritasi\", \"bulunan yer\"])",
    "",
    "# Sablon esleme ESNEK DEGILDIR: dondurulen sablon artik bulunamaz",
    "M = cv2.getRotationMatrix2D((tw // 2, th // 2), 20, 1.0)",
    "donuk_sablon = cv2.warpAffine(sablon, M, (tw, th))",
    "s2 = cv2.matchTemplate(kamera, donuk_sablon, cv2.TM_CCOEFF_NORMED)",
    "print(f\"20 derece dondurulmus sablonun en iyi benzerligi: {s2.max():.3f}  (cok dustu!)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Şablon eşleme ne zaman işe yarar?** Aradığınız şey her seferinde tıpatıp aynı görünüyorsa.",
    "Nesne döndüyse/büyüdüyse işe yaramaz — CNN'e giden yolu açan şey bu esneklik ihtiyacı."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 19 · Ders notundaki örnek görüntüleri kullanmak",
    "",
    "Ders notunun **4. bölümündeki** düğmelerle beş örnek görüntüyü PNG olarak indirebilirsiniz",
    "(`hafta4-manzara.png`, `hafta4-paralar.png`, `hafta4-sekiller.png`, `hafta4-yazi.png`,",
    "`hafta4-satranc.png`). Bunları Kaggle'a bir veri seti olarak yükleyip tarayıcıda gördüğünüz",
    "sonucun **aynısını** burada üretebilirsiniz.",
    "",
    "**Yükleme:** Datasets → New Dataset → dosyaları sürükle → ad ver (`hafta4-ornek-goruntuler`)",
    "→ Create. Sonra notebook'ta sağ panelden **Add Input** ile ekleyin."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os",
    "",
    "KLASOR = \"/kaggle/input/hafta4-ornek-goruntuler\"",
    "",
    "if os.path.isdir(KLASOR):",
    "    print(sorted(os.listdir(KLASOR)))",
    "",
    "    def oku(ad, gri_mi=False):",
    "        yol = os.path.join(KLASOR, f\"hafta4-{ad}.png\")",
    "        bayrak = cv2.IMREAD_GRAYSCALE if gri_mi else cv2.IMREAD_COLOR",
    "        img = cv2.imread(yol, bayrak)",
    "        if img is None:",
    "            raise FileNotFoundError(yol)      # BU KONTROLU ASLA ATLAMAYIN",
    "        return img",
    "",
    "    d_manzara  = oku(\"manzara\")               # BGR (3 kanal)",
    "    d_paralar  = oku(\"paralar\",  gri_mi=True)",
    "    d_sayfa    = oku(\"yazi\",     gri_mi=True)",
    "    d_sekiller = oku(\"sekiller\", gri_mi=True)",
    "    d_satranc  = oku(\"satranc\",  gri_mi=True)",
    "",
    "    for ad, g in [(\"manzara\", d_manzara), (\"paralar\", d_paralar), (\"yazi\", d_sayfa)]:",
    "        print(f\"{ad:10s} {str(g.shape):18s} {g.dtype}\")",
    "",
    "    # Ders notundaki her adimi AYNI goruntuyle tekrarlayin",
    "    _, d_ikili = cv2.threshold(d_paralar, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)",
    "    d_kenar = cv2.Canny(cv2.GaussianBlur(d_satranc, (5, 5), 1.4), 40, 110)",
    "    d_uyar  = cv2.adaptiveThreshold(d_sayfa, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,",
    "                                    cv2.THRESH_BINARY, 25, 7)",
    "",
    "    goster([cv2.cvtColor(d_manzara, cv2.COLOR_BGR2RGB), d_ikili, d_kenar, d_uyar],",
    "           [\"manzara (BGR2RGB)\", \"paralar: Otsu\", \"satranc: Canny\", \"yazi: uyarlamali\"], satir=2)",
    "",
    "    cv2.imwrite(\"/kaggle/working/paralar-otsu.png\", d_ikili)",
    "    print(\"Kaydedildi: /kaggle/working/paralar-otsu.png\")",
    "else:",
    "    print(f\"{KLASOR} yok. Ders notundan PNG'leri indirip veri seti olarak yukleyin,\")",
    "    print(\"sonra sag panelden Add Input ile ekleyin. Bu hucre o zaman calisir.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Küçük ayrıntı:** indirdiğiniz PNG'ler renkli (3 kanal) kaydedilir — \"Şekiller\" ve",
    "\"Taranmış sayfa\" gözle siyah-beyaz görünse de dosya yine RGB'dir. Bu yüzden",
    "`IMREAD_GRAYSCALE` ile okuyoruz; sonradan `cvtColor` çağırmanız gerekmez."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 20 · Kendi dosyanızı okumak"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Kendi veri setinizi eklediyseniz (sag panel -> Add Input):",
    "import os",
    "if os.path.exists(\"/kaggle/input\"):",
    "    print(\"Mevcut girdiler:\", os.listdir(\"/kaggle/input\"))",
    "",
    "yol = \"/kaggle/input/BURAYA-VERI-SETI-ADINIZ/resim.jpg\"",
    "",
    "img = cv2.imread(yol)              # BGR olarak okur",
    "if img is None:",
    "    print(f\"Okunamadi: {yol}  (yolu sol panelden KOPYALAYIN, elle yazmayin)\")",
    "else:",
    "    gri_o = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)",
    "    goster([cv2.cvtColor(img, cv2.COLOR_BGR2RGB), gri_o], [\"kendi resmim\", \"gri\"])",
    "",
    "cv2.imwrite(\"/kaggle/working/cikti.png\", cv2.cvtColor(kamera, cv2.COLOR_GRAY2BGR))",
    "print(\"Kaydedildi: /kaggle/working/cikti.png\")",
    "",
    "# cv2.imshow(\"pencere\", img)   # <- NOTEBOOK'TA CALISMAZ, cekirdegi kilitler!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---",
    "",
    "## Ödev için kontrol listesi (A bölümü)",
    "",
    "Kendi veri setinizden en az 3 görüntü seçip şu zinciri uygulayın:",
    "",
    "1. Gri tonlama + **histogram** grafiği",
    "2. **Üç eşikleme**: elle, Otsu, uyarlamalı — hangisi işe yaradı, **neden**?",
    "3. **Kenar**: Sobel büyüklüğü ve Canny, eşikler kendi verinize göre ayarlı",
    "4. **Morfoloji**: açma + kapama ile temizleme",
    "5. **Kontur**: nesne sayma ya da en büyük nesnenin alanı/çevresi, sonuç görüntü üstüne çizili",
    "",
    "Sonra bir paragraf: *\"Bu problem klasik yöntemle çözülebilir miydi?\"* — gerekçelendirin.",
    "",
    "**Sonra CNN notebook'una geçin.**"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.11.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}