Sis, dış mekan fotoğraflarında sıkça karşılaşılan bir sorundur. Atmosferdeki toz, nem ve diğer partiküller, ışığın dağılmasına ve emilmesine neden olarak görüntüdeki kontrastı ve renk doğruluğunu azaltır. Bu durum, özellikle uzak mesafedeki nesnelerin detaylarının kaybolmasına yol açar. Geleneksel yöntemler, birden fazla görüntü veya ek donanım gerektirirken, tek görüntü sis kaldırma teknikleri bu sorunu çözmek için yenilikçi bir yaklaşım sunmaktadır.

Dark Channel Prior (Karanlık Kanal Öncelikli) algoritması, ilk olarak Kaiming He ve ekibi tarafından sisli görüntülerden net görüntüler elde etme amacıyla geliştirilmiştir.

Dark Channel Prior (DCP)

DCP, sisli olmayan dış mekan görüntülerinde gözlemlenen istatistiksel bir özelliğe dayanır. He ve arkadaşları (2009), 5.000'den fazla sisli olmayan görüntü üzerinde yaptıkları analizde, gökyüzü gibi parlak alanlar hariç, çoğu yerel yamada (local patch) en az bir renk kanalında (kırmızı, yeşil veya mavi) piksel yoğunluğunun çok düşük olduğunu bulmuşlardır. Bu düşük yoğunluk, genellikle gölgeler, koyu renkli nesneler veya parlak olmayan yüzeylerden kaynaklanır. Matematiksel olarak, karanlık kanal şu şekilde tanımlanır:

$J_dark(x) = min_{c ∈ {r,g,b}} (min_{y ∈ Ω(x)} J^c(y))$

Burada, J(x) sisli olmayan görüntü, c renk kanallarını (R, G, B), Ω(x) ise x merkezli yerel yamayı temsil eder. Sisli görüntülerde, bu karanlık kanal yoğunluğu atmosferik ışık tarafından artırılır ve bu artış, sis yoğunluğunu tahmin etmek için kullanılır.

Sis Modeli ve Matematiksel Temel

Sisli görüntülerin oluşumu, atmosferik dağılma modeline dayanır. Bu model, şu formülle ifade edilir:

$I(x) = J(x) * t(x) + A * (1 - t(x))$

I(x): Sisli görüntü
J(x): Sisli olmayan (net) görüntü
t(x): İletim haritası (transmission map), yani ışığın sahneden kameraya ulaşma oranı
A: Atmosferik ışık (genellikle en parlak piksel)

İletim haritası, t(x) = e^(-β d(x)) formülüyle hesaplanır; burada β dağılma katsayısı, d(x) ise sahne derinliğidir. Sis yoğunluğu arttıkça t(x) azalır ve görüntüdeki kontrast kaybolur. Karanlık kanal öncelikli algoritma, bu modeli tersine çevirerek J(x)’i geri kazanmayı amaçlar.

Orijinal Karanlık Kanal Öncelikli Algoritmasının Adımları

He ve arkadaşları (2009) tarafından geliştirilen orijinal algoritma, sis kaldırma işlemini beş temel adımda gerçekleştirir.

1- Atmosferik Işığın Tahmini

Atmosferik ışık (A), genellikle görüntünün en parlak bölgesinden tahmin edilir. He ve ekibi, karanlık kanalın en parlak %0,1’lik pikselini seçer ve bu piksellerin ortalamasını alarak A’yı hesaplar. Bu yöntem, doğrudan en parlak pikseli seçmekten daha robust bir sonuç verir, çünkü gürültü veya parlak nesnelerden kaynaklanan hataları azaltır.

2- Karanlık Kanalın Hesaplanması

Görüntü, yerel yamalara (örneğin 15x15 piksel) bölünür. Her yamada, her renk kanalındaki minimum yoğunluk bulunur ve bu minimumlar arasında en düşük olanı karanlık kanal olarak seçilir:

$I_dark(x) = min_{c ∈ {r,g,b}} (min_{y ∈ Ω(x)} I^c(y))$

Bu işlem, Marcel van Herk’in hızlı minimum filtresi ile etkin bir şekilde gerçekleştirilir ve hesaplama karmaşıklığı görüntü boyutuna lineer olarak ölçeklenir.

3- İletim Haritasının İlk Tahmini

Karanlık kanal kullanılarak iletim haritası şu formülle hesaplanır:

$t(x) = 1 - ω * (min_{c} (min_{y ∈ Ω(x)} I^c(y) / A^c))$

Burada ω, sis miktarını kontrol eden bir parametredir ve genellikle 0.95 olarak alınır. Bu değer, tamamen sis kaldırmak yerine hafif bir sis kalıntısı bırakarak doğal bir görünüm sağlar.

4- İletim Haritasının Rafine Edilmesi

İlk tahmin edilen iletim haritası, genellikle gürültülü ve kenarları bulanık olabilir. Bu nedenle, yumuşak matlama (soft matting) veya yönlendirilmiş filtreleme (guided filtering) gibi tekniklerle rafine edilir. Yumuşak matlama, şu maliyet fonksiyonunu minimize eder:

$E(t) = t^T L t + λ (t - t_hat)^T (t - t_hat)$

Burada L Laplacian matrisi, λ ise düzenleme parametresidir (örneğin, 10^-4). Bu adım, kenarları korurken gürültüyü azaltır.

5- Net Görüntünün Geri Kazanımı

Son adımda, sisli görüntüden net görüntü şu formülle elde edilir:

$J(x) = (I(x) - A) / max(t(x), t_0) + A$

Burada t_0 (örneğin 0.1), sıfıra bölünmeyi önlemek için kullanılan bir alt sınırdır. Bu formül, sis etkisini tersine çevirerek net bir görüntü üretir.

Algoritmanın Avantajları ve Sınırlamaları

Karanlık kanal öncelikli algoritma, tek bir görüntüden sis kaldırmada etkileyici sonuçlar sunar ve ek donanım gerektirmez. Ancak, bazı sınırlamaları da vardır:

Parlak Alanlar: Gökyüzü gibi homojen ve parlak bölgelerde, karanlık kanal varsayımı geçerli olmayabilir. Bu alanlarda piksel yoğunluğu sıfıra yakın değildir, bu da renk bozulmasına veya gürültüye neden olabilir.
Benzer Renk Sorunu: Sahnedeki nesnelerin renkleri atmosferik ışığa yakınsa (örneğin, beyaz bir bina), algoritma yanlış tahminler yapabilir.
Hesaplama Karmaşıklığı: Yumuşak matlama gibi rafinasyon adımları, hesaplama açısından yoğun olabilir.

Uygulama Alanları

Karanlık kanal öncelikli algoritma, birçok alanda kullanılabilir:

Fotoğrafçılık: Sisli dış mekan fotoğraflarını iyileştirme.
Otonom Araçlar: Kamera tabanlı sistemlerin sisli havalarda görüşünü artırma.
Uydu Görüntüleme: Bulutlu veya sisli görüntülerin netleştirilmesi.
Güvenlik Sistemleri: Sisli ortamlarda güvenlik kameralarının etkinliğini artırma.

DCP Algoritma Uygulama Kodu

import cv2
import numpy as np
import matplotlib.pyplot as plt

#Görüntünün karanlık kanalları hesaplanır.
def dark_channel(image, window_size=15):
    min_channel = np.min(image, axis=2)
    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (window_size, window_size))
    dark = cv2.erode(min_channel, kernel)
    return dark

#Atmosferik ışık tahmin edilir.
def estimate_atmospheric_light(image, dark, top_percent=0.1):
    num_pixels = int(dark.shape[0] * dark.shape[1] * top_percent)
    flat_image = image.reshape(-1, 3)
    flat_dark = dark.reshape(-1)
    indices = np.argsort(flat_dark)[-num_pixels:]
    atmospheric_light = np.max(flat_image[indices], axis=0)
    return atmospheric_light

#İletim haritası tahmin edilir.
def estimate_transmission(image, atmospheric_light, window_size=15, omega=0.95):
    normalized_image = image / atmospheric_light
    dark = dark_channel(normalized_image, window_size)
    transmission = 1 - omega * dark
    return transmission

#Guided filtresi uygulanır.
def guided_filter(image, p, r=40, eps=1e-3):
    mean_I = cv2.boxFilter(image, cv2.CV_64F, (r, r))
    mean_p = cv2.boxFilter(p, cv2.CV_64F, (r, r))
    mean_Ip = cv2.boxFilter(image * p, cv2.CV_64F, (r, r))
    cov_Ip = mean_Ip - mean_I * mean_p

    mean_II = cv2.boxFilter(image * image, cv2.CV_64F, (r, r))
    var_I = mean_II - mean_I * mean_I

    a = cov_Ip / (var_I + eps)
    b = mean_p - a * mean_I

    mean_a = cv2.boxFilter(a, cv2.CV_64F, (r, r))
    mean_b = cv2.boxFilter(b, cv2.CV_64F, (r, r))

    q = mean_a * image + mean_b
    return q

#Görüntü Keskinleştirme
def sharpen_image(image):
    kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]])
    sharpened_image = cv2.filter2D(image, -1, kernel)
    return sharpened_image

sharpened_image = sharpen_image(dehazed_image)

#CLAHE ile kontrast artırma
def enhance_contrast(image):
    lab = cv2.cvtColor(image, cv2.COLOR_RGB2LAB)
    l, a, b = cv2.split(lab)
    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
    l = clahe.apply(l)
    lab = cv2.merge((l, a, b))
    enhanced_image = cv2.cvtColor(lab, cv2.COLOR_LAB2RGB)
    return enhanced_image

enhanced_image = enhance_contrast(dehazed_image)

#Sis giderme işlemi
def dehaze(image, window_size=15, omega=0.95, t0=0.1, r=40, eps=1e-3):
    image = image.astype(np.float32) / 255.0   # Görüntü normalize edilir

    dark = dark_channel(image, window_size) #Karanlık kanal hesaplanır

    atmospheric_light = estimate_atmospheric_light(image, dark) #Atmosferik ışık tahmin edilir

    transmission = estimate_transmission(image, atmospheric_light, window_size, omega) #iletim haritası tahmin edilir
    transmission = np.clip(transmission, t0, 1.0)

    gray_image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY) # Guided Filter ile iletim haritası iyileştirilir
    refined_transmission = guided_filter(gray_image, transmission, r, eps)

    dehazed_image = np.zeros_like(image) #Sis giderilmiş görüntü hesaplanır
    for i in range(3):
        dehazed_image[:, :, i] = (image[:, :, i] - atmospheric_light[i]) / refined_transmission + atmospheric_light[i]

    dehazed_image = np.clip(dehazed_image, 0, 1)
    dehazed_image = (dehazed_image * 255).astype(np.uint8) # Görüntüyü [0, 1] aralığından [0, 255] aralığına dönüştürülür

    return dehazed_image

# Sisli görüntü yüklenir.
hazy_image = cv2.imread('goruntu_dosya_yolu')
hazy_image = cv2.cvtColor(hazy_image, cv2.COLOR_BGR2RGB)

# Sis giderme işlemi uygulanır.
dehazed_image = dehaze(hazy_image)

# Sonuçların görselleştirilmesi
plt.figure(figsize=(10, 5))
plt.subplot(1, 2, 1)
plt.title('Sisli Görüntü')
plt.imshow(hazy_image)
plt.subplot(1, 2, 2)
plt.title('Sis Giderilmiş Görüntü')
plt.imshow(dehazed_image)
plt.show()

Örnek Çıktı:

^{Dark Channel Prior algoritmasının uygulaması (Hazırlayan ve düzenleyen: Beyza Nur Türkü)}

Dark Channel Prior Algoritması