Bilgisayarlı Görme Disiplininin Evrimi

İnsan beyni için bir görseli algılamak, saliseler içinde gerçekleşen ve efor gerektirmeyen biyolojik bir süreçtir. Karşıdan karşıya geçen bir yayayı, hareket eden bir aracı veya masanın üzerindeki bir bardağı anında tanır, konumlandırır ve uzamsal derinliğini zihnimizde haritalandırırız. Ancak bir bilgisayar için görsel dünya bundan çok uzaktır — her görsel, yalnızca Yükseklik × Genişlik × Kanal boyutlarında, 0–255 arasında değerler alan piksel yoğunluk matrislerinden (Pixel Intensity Matrices) ibarettir.

Bilgisayarlı Görme (Computer Vision) disiplininin temel amacı; bu sayısal matris dizilimlerinden anlamlı, anlamsal (semantic) ve karar vermeye elverişli yüksek seviyeli bilgiler çıkarmaktır.

Sınıflandırma ve Tespit Arasındaki Kritik Fark

Görüntü işleme dünyasına yeni adım atanların sıklıkla karıştırdığı iki temel kavram vardır:

• Görüntü Sınıflandırma (Classification): "Bu görselde ne var?" sorusuna yanıt arar. Çıktı olarak tek bir etiketin olasılık dağılımını (softmax) üretir — nesnenin görselin neresinde olduğuyla ilgilenmez.
• Nesne Tespiti (Detection): "Bu görselde ne, nerede?" sorularına aynı anda yanıt verir. Model hem sınıfı belirler hem de nesneyi kapsayan sınırlayıcı kutunun (bounding box) uzamsal koordinatlarını tahmin eder.

Burada (x, y) sınırlayıcı kutunun merkez koordinatları, (w, h) genişlik/yükseklik, Cⁱ ise nesnenin i. sınıfa ait olma olasılık skorudur (confidence score).

Uçtan Uca Bilgisayarlı Görme Hattı

Karmaşık bir otonom sürüş veya video analiz sisteminde nesne işleme süreci tek bir adımdan oluşmaz; aşamalı bir pipeline olarak kurgulanır:

1. Nesne TespitiGörsel üzerindeki anlamsal nesneler (x, y, w, h) olarak konumlandırılır.
2. Nesne TakibiVideo akışı boyunca ardışık karelerde aynı nesneye benzersiz bir kimlik (ID) atanarak hareketi kestirilir.
3. SınıflandırmaTespit edilen bölgenin (ROI) ince detay sınıflandırması veya öznitelik çıkarımı tamamlanır.

Geleneksel OpenCV mi, Derin Öğrenme mi?

Bu yazı serisinde, piksellerin doğrudan matris manipülasyonundan başlayarak geleneksel OpenCV filtrelerini inceleyecek, ardından kendi CNN modellerimizi eğitecek ve nihayetinde ResNet, Sliding Window ve NMS gibi ileri seviye derin öğrenme mimarileriyle hibrit çözümler geliştireceğiz.

OpenCV ile Geleneksel Nesne Tespiti Teknikleri

Derin öğrenme çağından önce bilgisayarlı görme dünyası, görsellerin türevsel ve istatistiksel özelliklerine dayanan elle tasarlanmış özniteliklere (hand-crafted features) kuruluydu. Bu bölümde piksel düzeyindeki manipülasyonlardan başlayarak kural tabanlı nesne tespit algoritmalarını ele alıyoruz.

1.1 — Kenar Tespiti: Canny Yöntemi

Kenarlar, piksel parlaklık değerlerinin ani değişim gösterdiği süreksizlik noktalarıdır. Canny Edge Detector beş adımlı bir pipeline çalıştırır: Gaussian Blur → Gradyan Hesabı → Non-Maximum Suppression → Double Thresholding → Hysteresis ile kenar takibi.

import cv2
import numpy as np

def auto_canny(image, sigma=0.33):
    # Görselin medyan piksel değerini hesapla
    v = np.median(image)

    # Otomatik alt ve üst eşik değerlerini belirle
    lower = int(max(0, (1.0 - sigma) * v))
    upper = int(min(255, (1.0 + sigma) * v))

    # Canny uygula
    edged = cv2.Canny(image, lower, upper)
    return edged

1.2 — Köşe Tespiti: Harris & Shi-Tomasi

Köşeler, her yönde piksel yoğunluğunun keskin değişim gösterdiği (iki kenarın kesişimi) ve takibi en kolay olan öznitelik noktalarıdır.

Shi-Tomasi yanıt fonksiyonunu λ = min(λ₁, λ₂) olarak sadeleştirir; λ > λ_threshold ise nokta köşe kabul edilir. Nesne takibinde "takip edilebilir en iyi noktalar" bu yöntemle seçilir.

# Shi-Tomasi Köşe Tespiti
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
corners = cv2.goodFeaturesToTrack(
    gray, maxCorners=100, qualityLevel=0.01, minDistance=10
)
corners = np.int0(corners)
for i in corners:
    x, y = i.ravel()
    cv2.circle(img, (x, y), 3, (0, 255, 0), -1)

1.3 — Kontur Analizi ve HSV Renk Segmentasyonu

RGB renk uzayı ortam ışığındaki değişimlere karşı son derece duyarlıdır. Bu nedenle renk bazlı tespitte HSV (Hue, Saturation, Value) uzayına geçilir; cv2.inRange() ile ikili maske oluşturulur ve maskedeki gürültü erozyon/genişleme ile temizlenir.

# BGR -> HSV Dönüşümü
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

# Mavi renk için alt/üst sınır maskesi
lower_blue = np.array([84, 98, 0])
upper_blue = np.array([179, 255, 255])
mask = cv2.inRange(hsv, lower_blue, upper_blue)

# Morfolojik gürültü temizleme
mask = cv2.erode(mask, None, iterations=2)
mask = cv2.dilate(mask, None, iterations=2)

# Kontur tespiti ve en büyük konturun kutusu
contours, _ = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
if len(contours) > 0:
    c = max(contours, key=cv2.contourArea)
    rect = cv2.minAreaRect(c)
    box = np.int0(cv2.boxPoints(rect))
    cv2.drawContours(frame, [box], 0, (0, 255, 255), 2)

1.4 — Şablon & Özellik Eşleştirme

Template Matching (cv2.matchTemplate), küçük bir şablonu ana görsel üzerinde kaydırarak korelasyon haritası çıkarır — fakat ölçek ve rotasyon değişimlerine tamamen duyarsızdır. Ölçek/açı bağımsız tespit için öznitelik tanımlayıcılar kullanılır:

• ORB — hızlı, patent kısıtlaması olmayan binary tanımlayıcı.
• SIFT — Gaussian piramitleri ve DoG (Difference of Gaussians) ile ölçek/rotasyona son derece dirençli anahtar noktalar üretir.

sift = cv2.SIFT_create()
kp1, des1 = sift.detectAndCompute(img_obj, None)
kp2, des2 = sift.detectAndCompute(img_scene, None)

bf = cv2.BFMatcher()
matches = bf.knnMatch(des1, des2, k=2)

# Lowe's Ratio Test ile kaliteli eşleşmeleri filtreleme
good_matches = []
for m, n in matches:
    if m.distance < 0.75 * n.distance:
        good_matches.append(m)

1.5 — Havza (Watershed) Algoritması

Birbirine dokunan veya çakışan nesneleri (örn. yan yana duran bozuk paralar) ayrıştırmak için Watershed, gri seviye görseli topografik bir yüzey olarak ele alır: yüksek piksel genlikleri tepeleri, düşük genlikler vadileri temsil eder; farklı vadilerden gelen "su"ların birleştiği noktalara sınır çizgileri inşa edilir.

# 1. Mesafe dönüşümü ile nesne merkezlerini bulma
dist_transform = cv2.distanceTransform(opening, cv2.DIST_L2, 5)
_, sure_fg = cv2.threshold(dist_transform, 0.4 * dist_transform.max(), 255, 0)

# 2. Bilinmeyen (sınır) bölgeyi belirleme
sure_fg = np.uint8(sure_fg)
unknown = cv2.subtract(sure_bg, sure_fg)

# 3. Etiketleme ve Watershed uygulaması
_, markers = cv2.connectedComponents(sure_fg)
markers = markers + 1
markers[unknown == 255] = 0
markers = cv2.watershed(img, markers)
img[markers == -1] = [0, 0, 255]  # sınırları kırmızı işaretle

1.6 — Haar Cascade ve HOG ile İstatistiksel Sınıflandırma

Girdi Görseli
   │
   ▼
Integral Image Hesabı  ──▶  Haar-like Özellik Çıkarımı
                                       │
                                       ▼
                        AdaBoost: En Ayırt Edici Özellik Seçimi
                                       │
                                       ▼
        [Stage 1] ──▶ [Stage 2] ──▶ ... ──▶ [Stage N] ──▶ Tespit

Paul Viola ve Michael Jones (2001) tarafından önerilen bu mimari gerçek zamanlı yüz tespiti yapabilen ilk yöntemdir. Kendi nesnenizi (örn. bir kalem ucu) tespit etmek için pozitif/negatif görseller toplanır ve opencv_traincascade ile özel bir .xml modeli üretilir.

face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')

faces = face_cascade.detectMultiScale(
    gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30)
)
for (x, y, w, h) in faces:
    cv2.rectangle(img, (x, y), (x+w, y+h), (255, 0, 0), 2)

HOG (Histogram of Oriented Gradients), lokal kenar/köşe yönelimlerinin dağılımını histogram olarak çıkarır; elde edilen vektör bir SVM sınıflandırıcıya verilerek yaya tespiti yüksek doğrulukla gerçekleştirilir:

hog = cv2.HOGDescriptor()
hog.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector())

rects, weights = hog.detectMultiScale(image, winStride=(8, 8), padding=(8, 8), scale=1.05)

Geleneksel yöntemler kural bazlı yapıları sayesinde eğitim verisine ihtiyaç duymadan, düşük donanım kaynaklarıyla hızlı sonuç üretir; ancak renk, açı, ışık ve ölçek değişimlerinin karmaşıklaştığı gerçek dünya senaryolarında kırılganlaşırlar. Zaman boyutundaki hareketi analiz etmek için sırada Nesne Takibi var.

Zaman Boyutunda Nesne Takibi (Object Tracking)

Nesne tespiti her video karesini bağımsız bir statik görsel olarak ele alır; ancak her karede ağır tespit algoritmaları koşturmak hesaplama açısından son derece verimsizdir. Nesne Takibi, tespit edilmiş bir nesnenin konumunu ardışık kareler boyunca geçmiş bilgi ve hareket vektörleriyle kestirme disiplinidir.

2.1 — Mühendislik Zorlukları

• Tıkanma (Occlusion): nesnenin geçici olarak görünmez olması.
• Kimlik Değişimi (ID Switch): kesişen nesnelerin etiketlerinin yer değiştirmesi.
• Ölçek/Perspektif Değişimi: kameraya yaklaşan nesnenin kutu boyutunun sürekli değişmesi.
• Görünme/Kaybolma: nesnelerin kareye beklenmedik girip çıkması.

2.2 — Meanshift ve Camshift

Meanshift, veri noktalarının en yoğun olduğu bölgeye (mode) doğru yinelemeli kayan bir kümeleme yaklaşımıdır: ROI'nin HSV histogramı çıkarılır, mevcut karede olasılık haritası (Back-Projection) hesaplanır ve pencere kütle merkezine kaydırılır. Sınırlılığı, pencere boyutunun sabit kalmasıdır.

Camshift bunu geliştirerek pencere boyutunu ve rotasyonunu kütle momentlerine göre dinamik olarak günceller.

# ROI Seçimi ve HSV Back-Projection hazırlığı
hsv_roi = cv2.cvtColor(roi_frame, cv2.COLOR_BGR2HSV)
roi_hist = cv2.calcHist([hsv_roi], [0], None, [180], [0, 180])
cv2.normalize(roi_hist, roi_hist, 0, 255, cv2.NORM_MINMAX)

term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1)

while True:
    ret, frame = cap.read()
    if not ret: break

    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
    dst = cv2.calcBackProject([hsv], [0], roi_hist, [0, 180], 1)

    # Camshift ile pencere boyutunu adaptif güncelleme
    ret, track_window = cv2.CamShift(dst, track_window, term_crit)
    pts = np.int0(cv2.boxPoints(ret))
    cv2.polylines(frame, [pts], True, (0, 255, 0), 2)

2.3 — MOT17 Benchmark Karşılaştırması

OpenCV'nin temel takip algoritmalarının MOT17 (Multiple Object Tracking Benchmark) verisi üzerindeki karakteristikleri:

2.4 — Öklid Mesafesi ile Hata Analizi

Bir takip algoritmasının başarısı, Ground-Truth koordinatları ile modelin ürettiği track koordinatları arasındaki Öklid mesafesi ile ölçülür:

import pandas as pd
import numpy as np

gt_df = pd.read_csv('GroundTruth_new.txt')

def calculate_tracking_error(gt_df, track_df):
    merged = pd.merge(gt_df, track_df, on='frame_no')
    error = np.sqrt(
        (merged['center_x_gt'] - merged['center_x_track'])**2 +
        (merged['center_y_gt'] - merged['center_y_track'])**2
    )
    return np.sum(error)

2.5 — Çoklu Nesne Takibi (MOT)

Gerçek hayat senaryolarında (bir caddedeki tüm yayalar ve araçlar) eş zamanlı takip gerekir. cv2.MultiTracker_create() tekil takip algoritmalarını paralel yöneterek çoklu nesne takibi sağlar.

trackers = cv2.MultiTracker_create()

for box in selected_boxes:
    tracker = cv2.TrackerCSRT_create()
    trackers.add(tracker, frame, box)

while True:
    ret, frame = cap.read()
    if not ret: break

    success, boxes = trackers.update(frame)
    for box in boxes:
        x, y, w, h = [int(v) for v in box]
        cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0), 2)

Klasik takip algoritmaları düşük seviyeli özniteliklerle hız kazandırsa da, derin öğrenmenin sunduğu anlamsal öznitelik çıkarımından yoksundur. Görsel dünyayı anlamsal düzeyde kavramak için sırada CNN var.

Evrişimsel Sinir Ağları (CNN) & Uçtan Uça Projeler

Geleneksel yöntemlerin en büyük kısıtlılığı, özniteliklerin mühendis tarafından elle tanımlanma zorunluluğudur. Evrişimsel Sinir Ağları (CNN), görsel verinin matrisel yapısını bozmadan uzamsal hiyerarşileri otomatik olarak öğrenen mimarilerdir.

3.1 — Katmanların Matematiksel Mantığı

Girdi Görseli
   │
   ▼
┌───────────────────────────────┐
│ 1. Feature Extraction          │
│    Convolution + ReLU          │
│    Padding · Max Pooling       │
└───────────────────────────────┘
   │
   ▼
┌───────────────────────────────┐
│ 2. Classification               │
│    Flatten · Dense + Dropout   │
│    Output (Softmax)            │
└───────────────────────────────┘

Evrişim (Convolution): görsel üzerinde kaydırılan matrisel filtrelere kernel denir; piksel bazlı çarpımların toplamı öznitelik haritasını oluşturur.

İlk katmanlar basit kenar ve renk geçişlerini (low-level), son katmanlar nesneye özel karmaşık formları (high-level) öğrenir.

ReLU Aktivasyonu: doğrusal olmayan ilişkileri öğrenebilmek için negatif değerleri sıfırlar:

Padding evrişimin küçülttüğü uzamsal boyutu korur; Max Pooling pencere içindeki maksimum değeri seçerek parametre sayısını azaltır ve modele küçük yer değiştirmelere direnç (translation invariance) kazandırır. Flatten 2D haritaları vektöre çevirir, Dropout nöronların bir kısmını rastgele kapatarak ezberlemeyi (overfitting) engeller, Dense katman ise Softmax ile nihai olasılık dağılımını üretir.

3.2 — Uygulamalı Projeler

Proje 1 — Veri Toplama

T-Rex'in önündeki engel bölgesine (ROI) odaklanan koordinatlar tanımlanır; klavyeden basılan Up, Down, Right aksiyonları görsellerle etiketlenip kaydedilir.

import mss
from PIL import Image

# T-Rex engel ROI koordinatları
mon = {"top": 300, "left": 770, "width": 250, "height": 100}
sct = mss.mss()

sct_img = sct.grab(mon)
img = Image.frombytes("RGB", sct_img.size, sct_img.rgb)
img.save(f"./image/up_{record_id}_{i}.png")

Proje 1 — Model Mimarisi

from keras.models import Sequential
from keras.layers import Conv2D, MaxPooling2D, Dropout, Flatten, Dense

model = Sequential()
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(50, 125, 1)))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.4))
model.add(Dense(3, activation='softmax'))  # Down, Right, Up

model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
model.fit(train_x, train_y, epochs=35, batch_size=64)

Proje 2 — Ön İşleme & Data Augmentation

def preProcessing(img):
    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    img = cv2.equalizeHist(img)     # kontrast artırma
    img = img / 255.0              # normalizasyon
    return img

dataGen = ImageDataGenerator(
    width_shift_range=0.1,
    height_shift_range=0.1,
    zoom_range=0.1,
    rotation_range=10
)

Proje 2 — Canlı Kamera Uygulaması

Model 15 epoch sonunda %97 üzeri test doğruluğuna ulaşır. Tahmin olasılığı 0.7'nin üzerindeyse tespit kutusu üzerine etiket ve güven skoru yazdırılır:

classIndex = int(model.predict_classes(img))
predictions = model.predict(img)
probValue = np.amax(predictions)

if probValue > 0.7:
    cv2.putText(frame, f"Rakam: {classIndex} ({round(probValue*100, 2)}%)",
                (50, 50), cv2.FONT_HERSHEY_DUPLEX, 1, (0, 255, 0), 2)

CNN mimarileri yüksek doğruluklu sınıflandırma sağlar; fakat bir nesneyi sınıflandırmak, o nesnenin görüntü üzerindeki yerini (x, y, w, h) bulmak için tek başına yeterli değildir. Sırada Bounding Box tespiti var.

Derin Öğrenme Tabanlı İleri Seviye Nesne Tespiti

CNN sınıflandırıcıları görüntü sınıflandırmada insanüstü performans gösterse de, bir görsel üzerindeki birden fazla nesneyi aynı anda konumlandırmakta tek başına yetersiz kalır. Bu bölümde kayan pencerelerden bölge önerisine, iki aşamalı R-CNN'den tek aşamalı YOLO/SSD'ye uzanan evrimi inceliyoruz.

4.1 — Image Pyramid & Sliding Window

Girdi Görseli
   │
   ▼
1. Image Pyramid (çoklu ölçekleme)
   │
   ▼
2. Sliding Window (kayan pencere ile ROI)
   │
   ▼
3. ResNet-50 Classification (pencereyi sınıflandır)
   │
   ▼
4. Non-Maximum Suppression (çakışan kutuları ele)

def image_pyramid(image, scale=1.5, min_size=(224, 224)):
    yield image
    while True:
        w = int(image.shape[1] / scale)
        image = cv2.resize(image, (w, int(image.shape[0] / scale)))
        if image.shape[0] < min_size[1] or image.shape[1] < min_size[0]:
            break
        yield image

def sliding_window(image, step_size, window_size):
    for y in range(0, image.shape[0] - window_size[1], step_size):
        for x in range(0, image.shape[1] - window_size[0], step_size):
            yield (x, y, image[y:y + window_size[1], x:x + window_size[0]])

4.2 — Non-Maximum Suppression & IoU

Kayan pencere aynı nesne üzerinde onlarca çakışan kutu üretir. NMS bunları eleyip tek bir kutu bırakır; örtüşme oranı IoU (Intersection over Union) ile ölçülür:

def non_max_suppression(boxes, probs, overlap_thresh=0.3):
    if len(boxes) == 0: return []

    boxes = boxes.astype("float")
    pick = []
    x1, y1 = boxes[:, 0], boxes[:, 1]
    x2, y2 = boxes[:, 2], boxes[:, 3]
    area = (x2 - x1 + 1) * (y2 - y1 + 1)
    idxs = np.argsort(probs)

    while len(idxs) > 0:
        last = len(idxs) - 1
        i = idxs[last]
        pick.append(i)

        xx1 = np.maximum(x1[i], x1[idxs[:last]])
        yy1 = np.maximum(y1[i], y1[idxs[:last]])
        xx2 = np.minimum(x2[i], x2[idxs[:last]])
        yy2 = np.minimum(y2[i], y2[idxs[:last]])

        w = np.maximum(0, xx2 - xx1 + 1)
        h = np.maximum(0, yy2 - yy1 + 1)
        overlap = (w * h) / area[idxs[:last]]      # IoU hesabı

        idxs = np.delete(idxs, np.concatenate(([last], np.where(overlap > overlap_thresh)[0])))

    return boxes[pick].astype("int")

4.3 — Selective Search & Region Proposals

Sliding window'un brute-force yaklaşımına alternatif olarak Selective Search, pikselleri renk/doku/boyut benzerliklerine göre gruplayan (graph-based segmentation) bir yöntemdir; milyonlarca nokta yerine nesne olma ihtimali yüksek ~2000 bölge önerisi üretir.

ss = cv2.ximgproc.segmentation.createSelectiveSearchSegmentation()
ss.setBaseImage(image)
ss.switchToSelectiveSearchFast()
rects = ss.process()   # ~2000 bölge önerisi

4.4 — İki Aşamalı ve Tek Aşamalı Detektörler

R-CNN ailesi (R-CNN → Fast R-CNN → Faster R-CNN), yavaş dış bölge önerisinden başlayıp süreci giderek ağın içine taşıyarak GPU'da gerçek zamanlıya yaklaşmıştır. YOLO, görseli S×S grid hücrelerine böler; her hücre nesnenin merkezini içeriyorsa doğrudan B adet kutu koordinatını ve sınıf olasılıklarını tek bir forward-pass'te üretir. SSD ise farklı derinlikteki katmanlardan (multi-scale feature maps) tespit yaparak sığ katmanlarda küçük, derin katmanlarda büyük nesneleri yakalar.

Mühendislik Değerlendirmesi

Bilgisayarlı Görme ve Yapay Zeka dünyası, temel piksel matematiğinden başlayıp milyarlarca parametreli tespit mimarilerine uzanan devasa bir mühendislik yolculuğudur. Bu seride yalnızca teorik kavramlarla sınırlı kalmadık; piksellerin matrisel yapısından canlı video akışlarında otonom kararlar alan sistemlere uzanan pratik bir mimari inşa ettik.

Hangi Senaryoda Hangi Yaklaşım?

Öne Çıkan Mühendislik Kazanımları

1. Piksel düzeyinde kontrolCanny, Harris, HSV ve Watershed ile nesnelerin matematiksel sınırlarını çıkarmayı öğrendik.
2. Zaman boyutunda takip analiziMOT17'de KCF, CSRT ve MOSSE'yi FPS ve Öklid hatası üzerinden kıyasladık.
3. Uçtan uca CNN & otomasyonEkrandan görüntü yakalayıp oynayan bir T-Rex ajanı ve canlı rakam sınıflandırıcı geliştirdik.
4. Modern detektör mimarisiSliding Window'un maliyetini analiz edip NMS, Selective Search, R-CNN, YOLO ve SSD'nin algoritmik avantajlarını kavradık.

Gelecek Trendler

Bilgisayarlı görme dünyası bugün Vision Transformers (ViT), açık kelime dağarcıklı gerçek-zamanlı tespit (YOLO-World vb.) ve Edge AI optimizasyonu (TensorRT, OpenVINO) ekseninde hızla gelişiyor. Ancak bu ileri mimarilerin arkasındaki karar mekanizmalarını doğru anlamak, piksellerin temel matrisel matematiğine ve geleneksel filtrelerin çalışma prensiplerine hâkim olmaktan geçiyor.