Uzamsal filtreleme, görüntü işleme ve sinyal işleme alanlarında sıkça kullanılan bir yöntemdir. Bu teknik, bir görüntünün piksellerini doğrudan manipüle ederek belirli özelliklerini değiştirmeyi amaçlar. Gürültü azaltma, kenar algılama, keskinleştirme veya bulanıklaştırma gibi işlemler, uzamsal filtreleme ile gerçekleştirilebilir.

Uzamsal Filtreleme

Uzamsal filtreleme, dijital görüntü işleme ve sinyal işleme alanlarında, bir görüntünün piksel değerlerini doğrudan manipüle ederek belirli özelliklerini değiştirmek veya iyileştirmek için kullanılan bir tekniktir. Bu yöntem, görüntünün uzamsal alanındaki (spatial domain) verilerle çalışır; yani, piksel koordinatları ve yoğunluk değerleri üzerinde işlemler gerçekleştirir. Uzamsal filtreleme, frekans alanındaki filtreleme tekniklerinden (örneğin, Fourier dönüşümüyle yapılan işlemler) farklıdır, çünkü herhangi bir dönüşüm yapmadan, görüntünün ham piksel verilerini kullanır.

Temel Prensip

Uzamsal filtrelemenin temelinde, bir "çekirdek" (kernel) veya "maske" adı verilen küçük bir matrisin görüntünün her pikseline uygulanması yatar. Bu çekirdek, bir pikselin değerini, komşu piksellerin değerleriyle birlikte ağırlıklı bir şekilde birleştirerek yeni bir çıktı değeri üretir. İşlem, görüntünün tamamına kaydırma (sliding window) yöntemiyle uygulanır. Bu süreç, matematiksel olarak "konvolüsyon" (convolution) olarak adlandırılır ve uzamsal filtrelemenin temel yapı taşını oluşturur.

Bir görüntü f(x,y) olarak temsil edildiğinde ve çekirdek h(m,n) olarak tanımlandığında, uzamsal filtreleme sonucu oluşan çıktı görüntüsü g(x,y) şu formülle hesaplanır:

$g(x,y)= \displaystyle\sum_{m=-a}^{a} \displaystyle\sum_{m=-b}^{b} h(m,n) . f(x-m, y-n)$

f(x,y): Orijinal görüntünün piksel yoğunluğu
h(m,n): Çekirdeğin ağırlık katsayıları
a ve b: Çekirdeğin boyutunu belirleyen yarı genişlikler (örneğin 3x3 bir çekirdek için a = b = 1)
g(x,y): Filtrelenmiş çıktı görüntüsünün piksel değeri.

Bu formül, çekirdeğin merkezinin her piksel üzerine yerleştirildiğini ve komşu piksellerin ağırlıklı toplamının hesaplandığını ifade eder.

İşleyiş Adımları

1- Çekirdek Seçimi: Örneğin 3x3 ortalama bir filtre kullanılır.

$h = \frac{1}{9}\begin{pmatrix} 1 & 1 & 1 \\ 1 & 1 & 1 \\ 1 & 1 & 1 \end{pmatrix}$

Bu çekirdek, her piksele eşit ağırlık verir (1/9).

2- Görüntü Üzerinde Kaydırma: Çekirdek, görüntünün sol üst köşesinden başlayarak her piksel üzerine yerleştirilir. Kenar pikseller için genellikle sıfır dolgusu (zero padding) veya yansıtma gibi yöntemler kullanılır.

3- Hesaplama: Görüntünün bir bölgesindeki piksel değerlerinin şu şekilde olduğu varsayılırsa,

$\begin{pmatrix} 10 & 20 & 30 \\ 40 & 50 & 60 \\ 70 & 80 & 90 \end{pmatrix}$

Çekirdek bu bölgeye şu şekilde uygulanır:

$g(1,1) = \frac{1}{9}(10+20+30+40+50+60+70+80+90) = \frac{450}{9} = 50$

Merkez pikselin yeni değeri 50 olur.

4- Sonuç: Bu işlem, görüntünün her pikseli için tekrarlanarak filtrelenmiş bir çıktı görüntüsü elde edilir.

^{Orijinal görüntü ile filtrelenmiş görüntü arasındaki piksel işlemi (Kredi:}^{Gonca İnönü}⁾

Uzamsal Filtrelemenin Amacı

Uzamsal filtreleme, farklı amaçlar için kullanılabilir:

Gürültü Azaltma: Görüntüdeki rastgele bozulmaları (örneğin, tuz ve biber gürültüsü) temizlemek.
Kenar Algılama: Görüntüdeki nesnelerin sınırlarını vurgulamak.
Bulanıklaştırma: Detayları yumuşatarak daha homojen bir görüntü elde etmek.
Keskinleştirme: Görüntüdeki detayları ve kontrastı artırmak.

Uzamsal Filtreleme Türleri

Uzamsal filtreleme türleri, temel olarak düşük geçişli filtreler (low-pass filters) ve yüksek geçişli filtreler (high-pass filters) olmak üzere iki ana kategoriye ayrılır. Uygulama yöntemine göre ise doğrusal filtreler ve doğrusal olmayan filtreler olmak üzere ikiye ayrılır.

Düşük Geçişli Filtreler (Low-Pass Filters)

Düşük geçişli filtreler, görüntüdeki düşük frekanslı bileşenleri korurken yüksek frekanslı bileşenleri (ani değişiklikler, keskin kenarlar gibi) bastırır. Bu filtreler, genellikle görüntüyü yumuşatmak (blurring) ve gürültüyü azaltmak için kullanılır.

Ortalama (Mean) Filtresi

Ortalama (Mean) Filtresi, her pikselin etrafında bir kernel oluşturur, bu kernel içerisindeki bölgedeki piksel değerlerinin ortalaması alınır ve filtrelenmiş görüntüdeki pikselin yeni değeri olarak atanır.

def mean_filter(image, kernel_size):
  height, width, channels = image.shape
  pad = kernel_size // 2

  filtered_image = np.zeros_like(image, dtype=np.uint8)

  for i in range(channels):
    padded_channel = np.pad(image[:, :, i], pad, mode='constant', constant_values=0)

    for y in range(height):
      for x in range(width):
        roi = padded_channel[y:y + kernel_size, x:x + kernel_size]
        mean_value = np.mean(roi)
        filtered_image[y,x,i] = int(mean_value)

  return filtered_image

image = cv2.imread('dosya_yolu', cv2.COLOR_BGR2RGB)

filtered_image1 = mean_filter(image, 5)
filtered_image2 = mean_filter(image, 7)
filtered_image3 = mean_filter(image, 10)

image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
image1 = cv2.cvtColor(filtered_image1, cv2.COLOR_RGB2BGR)
image2 = cv2.cvtColor(filtered_image2, cv2.COLOR_RGB2BGR)
image3 = cv2.cvtColor(filtered_image3, cv2.COLOR_RGB2BGR)

plt.figure(figsize=(20,10))

plt.subplot(1,4,1)
plt.imshow(image)
plt.title("Orijinal Görüntü")

plt.subplot(1,4,2)
plt.imshow(image1)
plt.title("Ortalama (Mean) Filtresi (5x5)")

plt.subplot(1,4,3)
plt.imshow(image2)
plt.title("Ortalama (Mean) Filtresi (7x7)")

plt.subplot(1,4,4)
plt.imshow(image3)
plt.title("Ortalama (Mean) Filtresi (10x10)")

plt.show()

^{Hazırlayan ve düzenleyen: Beyza Nur Türkü}

Gauss (Gaussian) Filtresi

Gauss Filtresi, görüntünün piksel değerlerini komşu piksellerle Gaussian dağılımına dayalı ağırlıklarla birleştirerek görüntüyü bulanıklaştırır. Piksellerin ağırlıkları mesafelerine göre değişir: merkeze yakın pikseller daha fazla ağırlık alır, uzak pikseller daha az ağırlık alır.

def gauss_kernel(size, sigma):
  ax = np.linspace(-(size // 2), size // 2, size)
  xx, yy = np.meshgrid(ax, ax)
  kernel = np.exp(-(xx**2 + yy**2) / (2.0 * sigma**2))

  return kernel / np.sum(kernel)

def gauss_filter(image, kernel_size, sigma):
  height, width, channels = image.shape
  pad = kernel_size // 2
  filtered_image = np.zeros_like(image, dtype=np.uint8)

  kernel = gauss_kernel(kernel_size, sigma)

  for i in range(channels):
    padded_channeş = np.pad(image[:, :, i], pad, mode='reflect')

    for y in range(height):
      for x in range(width):
        roi = padded_channeş[y:y + kernel_size, x:x + kernel_size]
        filtered_image[y, x, i] = int(np.sum(roi * kernel))

  return filtered_image

image = cv2.imread('dosya_yolu' , cv2.COLOR_BGR2RGB)

filtered_1 = cv2.filter2D(image, -1, gauss_kernel(5, 1))
filtered_2 = cv2.filter2D(image, -1, gauss_kernel(7, 2))
filtered_3 = cv2.filter2D(image, -1, gauss_kernel(9, 3))

image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
image1 = cv2.cvtColor(filtered_1, cv2.COLOR_RGB2BGR)
image2 = cv2.cvtColor(filtered_2, cv2.COLOR_RGB2BGR)
image3 = cv2.cvtColor(filtered_3, cv2.COLOR_RGB2BGR)

plt.figure(figsize=(20, 10))

plt.subplot(1, 4, 1)
plt.imshow(image)
plt.title("Orijinal Görüntü")

plt.subplot(1, 4, 2)
plt.imshow(image1)
plt.title("Gauss Filtresi (5x5, σ=1)")

plt.subplot(1, 4, 3)
plt.imshow(image2)
plt.title("Gauss Filtresi (7x7, σ=2)")

plt.subplot(1, 4, 4)
plt.imshow(image3)
plt.title("Gauss Filtresi (9x9, σ=3)")

plt.show()

^{Hazırlayan ve düzenleyen: Beyza Nur Türkü}

Medyan (Median) Filtresi

Medyan Filtresi, piksel değerlerini bir çekirdek içerisindeki piksel değerlerinin sıralı ortanca (medyan) değerleriyle değiştirir.

def medyan_filter(image, kernel_size):
  height, width, channels = image.shape
  filtered_image = np.zeros((height, width, channels), dtype=np.uint8)

  pad = kernel_size // 2

  padded_image = np.pad(image, ((pad, pad), (pad, pad), (0, 0)), mode='constant', constant_values=0)

  for i in range(height):
    for j in range(width):
      for k in range(channels):
        window = padded_image[i:i+kernel_size, j:j+kernel_size, k]

        sorted_values = np.sort(window.flatten())
        median_value = sorted_values[len(sorted_values) // 2]

        filtered_image[i, j, k] = median_value

  return filtered_image

image = cv2.imread('dosya_yolu', cv2.COLOR_BGR2RGB)

filtered_1 = medyan_filter(image, 5)
filtered_2 = medyan_filter(image, 7)
filtered_3 = medyan_filter(image, 10)

image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
image1 = cv2.cvtColor(filtered_1, cv2.COLOR_RGB2BGR)
image2 = cv2.cvtColor(filtered_2, cv2.COLOR_RGB2BGR)
image3 = cv2.cvtColor(filtered_3, cv2.COLOR_RGB2BGR)

plt.figure(figsize=(15,5))

plt.subplot(1,4,1)
plt.imshow(image)
plt.title("Orijinal Görüntü")

plt.subplot(1,4,2)
plt.imshow(image1)
plt.title("Medyan Filtresi (5x5)")

plt.subplot(1,4,3)
plt.imshow(image2)
plt.title("Medyan Filtresi (7x7)")

plt.subplot(1,4,4)
plt.imshow(image3)
plt.title("Medyan Filtresi (10x10)")

plt.show()

^{Hazırlayan ve düzenleyen: Beyza Nur Türkü}

Minimum Filtresi

Minimize Operatörü veya Minimum Filtresi, görüntüdeki her pikselin çevresindeki belirli bir bölge içerisindeki en küçük değeri alarak o pikselin yeni değeri olarak atar.

def min_filter(image, kernel_size):
  height, width, channels = image.shape
  pad = kernel_size // 2

  filtered_image = np.zeros_like(image)

  padded_image = cv2.copyMakeBorder(image, pad, pad, pad, pad, cv2.BORDER_REPLICATE)

  for i in range(channels):
    for k in range(height):
      for j in range(width):
        region = padded_image[k:k+kernel_size, j:j+kernel_size, i]
        filtered_image[k, j, i] = np.min(region)

  return filtered_image

image = cv2.imread('dosya_yolu', cv2.COLOR_BGR2RGB)

filtered_1 = min_filter(image, 5)
filtered_2 = min_filter(image, 7)
filtered_3 = min_filter(image, 10)

image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
image1 = cv2.cvtColor(filtered_1, cv2.COLOR_RGB2BGR)
image2 = cv2.cvtColor(filtered_2, cv2.COLOR_RGB2BGR)
image3 = cv2.cvtColor(filtered_3, cv2.COLOR_RGB2BGR)

plt.figure(figsize=(15,5))

plt.subplot(1,4,1)
plt.imshow(image)
plt.title("Orijinal Görüntü")

plt.subplot(1,4,2)
plt.imshow(image1)
plt.title("Minimum Filtresi (5x5)")

plt.subplot(1,4,3)
plt.imshow(image2)
plt.title("Minimum Filtresi (7x7)")

plt.subplot(1,4,4)
plt.imshow(image3)
plt.title("Minimum Filtresi (10x10)")

plt.show()

^{Hazırlayan ve düzenleyen: Beyza Nur Türkü}

Maksimum Filtresi

Maksimum Operatörü veya Maksimum Filtresi, görüntüdeki her pikselin çevresindeki belirli bir bölge içerisindeki en büyük değeri alarak o pikselin yeni değeri olarak atar.

def max_filter(image, kernel_size):
  height, width, channels = image.shape

  pad = kernel_size // 2

  filtered_image = np.zeros_like(image)

  padded_image = np.pad(image, ((pad, pad), (pad, pad), (0, 0)), mode='edge')

  for i in range(channels):
    for j in range(height):
      for k in range(width):
        region = padded_image[j:j+kernel_size, k:k+kernel_size, i]
        max_value = np.max(region)
        filtered_image[j, k, i] = max_value

  return filtered_image

image = cv2.imread('dosya_yolu', cv2.COLOR_BGR2RGB)

filtered_image = max_filter(image, 5)
filtered_image1 = max_filter(image, 7)
filtered_image2 = max_filter(image, 10)

image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
image1 = cv2.cvtColor(filtered_image, cv2.COLOR_BGR2RGB)
image2 = cv2.cvtColor(filtered_image1, cv2.COLOR_BGR2RGB)
image3 = cv2.cvtColor(filtered_image2, cv2.COLOR_BGR2RGB)

plt.figure(figsize=(15,5))

plt.subplot(1,4,1)
plt.imshow(image)
plt.title("Orijinal Görüntü")

plt.subplot(1,4,2)
plt.imshow(image1)
plt.title("Maksimum Filtresi (5x5)")

plt.subplot(1,4,3)
plt.imshow(image2)
plt.title("Maksimum Filtresi (7x7)")

plt.subplot(1,4,4)
plt.imshow(image3)
plt.title("Maksimum Filtresi (10x10)")

plt.show()

^{Hazırlayan ve düzenleyen: Beyza Nur Türkü}

Disk Filtresi

Disk Filtresinde kernel dairesel şekle sahiptir, bundan dolayı “disk” adını almıştır.

def disk_kernel(radius):
  size = 2*radius+1
  kernel = np.zeros((size, size), dtype=np.float32)
  center = radius

  for i in range(size):
    for j in range(size):
      if (i-center)**2 + (j-center) ** 2 <= radius**2:
        kernel[i, j] = 1

  kernel /= np.sum(kernel)
  return kernel

def disk_filter(image, radius):
  height, width, channels = image.shape
  kernel = disk_kernel(radius)
  k_size = kernel.shape[0]
  pad = radius

  padded_image = np.pad(image, ((pad, pad), (pad, pad), (0, 0)), mode='edge')
  filtered_image = np.zeros_like(image)

  for i in range(channels):
    for j in range(height):
      for k in range(width):
        region = padded_image[j:j+k_size, k:k+k_size, i]

        filtered_image[j, k, i] = np.sum(region * kernel)

  return filtered_image

image = cv2.imread('dosya_yolu', cv2.COLOR_BGR2RGB)

filtered_image = disk_filter(image, 5)
filtered_image1 = disk_filter(image, 7)
filtered_image2 = disk_filter(image, 10)

image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
image1 = cv2.cvtColor(filtered_image, cv2.COLOR_BGR2RGB)
image2 = cv2.cvtColor(filtered_image1, cv2.COLOR_BGR2RGB)
image3 = cv2.cvtColor(filtered_image2, cv2.COLOR_BGR2RGB)

plt.figure(figsize=(15,5))

plt.subplot(1,4,1)
plt.imshow(image)
plt.title("Orijinal Görüntü")

plt.subplot(1,4,2)
plt.imshow(image1)
plt.title("Disk Filtresi (radius = 5)")

plt.subplot(1,4,3)
plt.imshow(image2)
plt.title("Disk Filtresi (radius = 7)")

plt.subplot(1,4,4)
plt.imshow(image3)
plt.title("Disk Filtresi (radius = 10)")

plt.show()

^{Hazırlayan ve düzenleyen: Beyza Nur Türkü}

k-NN Filtresi

k-NN Filtresi (k-Nearest Neighbors Filter), pikselin çevresindeki komşularından en benzer k tane pikselin değerlerini dikkate alarak yeni bir değer hesaplar. “En benzer” kavramı genellikle yoğunluk benzerliği ile ilgilidir ve piksellerin ortalaması alınarak merkez pikselin değeri güncellenir.

def knn_filter(image, kernel_size, k):
  height, width, channels = image.shape
  filtered_image = np.zeros_like(image)
  pad = kernel_size // 2

  padded_image = np.pad(image, ((pad, pad), (pad, pad), (0, 0)), mode='edge')

  for i in range(channels):
    for j in range(height):
      for k in range(width):
        region = padded_image[j:j+kernel_size, k:k+kernel_size, i].flatten()
        sorted_values = np.sort(region)
        knn_value = np.mean(sorted_values[:k])
        filtered_image[j, k, i] = knn_value

  return filtered_image

image = cv2.imread('dosya_yolu', cv2.COLOR_BGR2RGB)

filtered_image = knn_filter(image, 5, 3)
filtered_image1 = knn_filter(image, 7, 3)
filtered_image2 = knn_filter(image, 10, 3)

image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
image1 = cv2.cvtColor(filtered_image, cv2.COLOR_BGR2RGB)
image2 = cv2.cvtColor(filtered_image1, cv2.COLOR_BGR2RGB)
image3 = cv2.cvtColor(filtered_image2, cv2.COLOR_BGR2RGB)

plt.figure(figsize=(15,5))

plt.subplot(1,4,1)
plt.imshow(image)
plt.title("Orijinal Görüntü")

plt.subplot(1,4,2)
plt.imshow(image1)
plt.title("k-NN Filtresi (5x5) k=3")

plt.subplot(1,4,3)
plt.imshow(image2)
plt.title("k-NN Filtresi (7x7) k=3")

plt.subplot(1,4,4)
plt.imshow(image3)
plt.title("k-NN Filtresi (10x10) k=3")

plt.show()

^{Hazırlayan ve düzenleyen: Beyza Nur Türkü}

Yüksek Geçişli Filtreler (High-Pass Filters)

Yüksek geçişli filtreler, görüntüdeki yüksek frekanslı bileşenleri (kenarlar, detaylar gibi) vurgularken düşük frekanslı bileşenleri (düz alanlar) bastırır. Bu filtreler, genellikle görüntü keskinleştirme veya kenar tespiti için kullanılır.

Sobel Filtresi

Sobel Filtresi, görüntüdeki yoğunluk değişimlerini hesaplayarak kenarları vurgular. Genellikle yatay ve dikey yöndeki gradyanları ayrı ayrı hesaplamak için iki farklı çekirdek kullanılır ve gradyanların birleşimiyle kenarların tam konumu ve gücü belirlenir.

def sobel_filter(image):
  gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

  sobel_x = np.array([[-1, 0, 1],
                         [-2, 0, 2],
                         [-1, 0, 1]], dtype=np.float32)

  sobel_y = np.array([[-1, -2, -1],
                         [ 0,  0,  0],
                         [ 1,  2,  1]], dtype=np.float32)

  height, width = gray.shape

  gradient_x = np.zeros_like(gray, dtype=np.float32)
  gradient_y = np.zeros_like(gray, dtype=np.float32)
  gradient_magnitude = np.zeros_like(gray, dtype=np.float32)

  padded_gray = np.pad(gray, 1, mode='constant', constant_values=0)

  for y in range(height):
        for x in range(width):
            region = padded_gray[y:y+3, x:x+3]
            gx = np.sum(region * sobel_x)
            gy = np.sum(region * sobel_y)

            gradient_x[y, x] = gx
            gradient_y[y, x] = gy
            gradient_magnitude[y, x] = np.sqrt(gx**2 + gy**2)

  gradient_x = cv2.normalize(gradient_x, None, 0, 255,
                             cv2.NORM_MINMAX).astype(np.uint8)
  gradient_y = cv2.normalize(gradient_y, None, 0, 255,
                             cv2.NORM_MINMAX).astype(np.uint8)
  gradient_magnitude = cv2.normalize(gradient_magnitude, None, 0, 255,
                                     cv2.NORM_MINMAX).astype(np.uint8)

  return gradient_x, gradient_y, gradient_magnitude

image = cv2.imread('dosya_yolu')

grad_x, grad_y, grad_mag = sobel_filter(image)

image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
grad_x = cv2.cvtColor(grad_x, cv2.COLOR_GRAY2BGR)
grad_y = cv2.cvtColor(grad_y, cv2.COLOR_GRAY2BGR)
grad_mag = cv2.cvtColor(grad_mag, cv2.COLOR_GRAY2BGR)

plt.figure(figsize=(20, 10))

plt.subplot(1, 4, 1)
plt.imshow(image)
plt.title("Orijinal Görüntü")

plt.subplot(1, 4, 2)
plt.imshow(grad_x)
plt.title('Sobel X')

plt.subplot(1, 4, 3)
plt.imshow(grad_y)
plt.title('Sobel Y')

plt.subplot(1, 4, 4)
plt.imshow(grad_mag)
plt.title('Sobel Filtresi')

plt.show()

^{Hazırlayan ve düzenleyen: Beyza Nur Türkü}

Prewitt Filtresi

Prewitt Filtresi, Sobel Filtresine benzer şekilde, görüntünün yoğunluk değişimlerini hesaplayarak kenar vurgular.

def prewitt_filter(image):
  gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

  prewitt_x = np.array([[-1, 0, 1],
                        [-1, 0, 1],
                        [-1, 0, 1]])

  prewitt_y = np.array([[-1, -1, -1],
                        [0,  0,  0],
                        [1,  1,  1]])

  height, width, channels = image.shape
  pad = 1
  padded_image = np.pad(image, ((pad, pad), (pad, pad), (0, 0)), mode='edge')
  filtered_image = np.zeros_like(image, dtype=np.float32)

  for i in range(channels):
    for j in range(height):
      for k in range(width):
        region = padded_image[j:j+3, k:k+3, i]

        Gx = np.sum(region * prewitt_x)
        Gy = np.sum(region * prewitt_y)

        filtered_image[j, k, i] = np.sqrt(Gx**2 + Gy**2)

  filtered_image = (filtered_image / filtered_image.max()) * 255
  filtered_image = np.clip(filtered_image, 0, 255).astype(np.uint8)
  return filtered_image

image = cv2.imread('dosya_yolu')

filtered_image = prewitt_filter(image)

#image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
#new_image = cv2.cvtColor(filtered_image, cv2.COLOR_BGR2RGB)

plt.figure(figsize=(20, 10))

plt.subplot(1, 4, 1)
plt.imshow(image)
plt.title("Orijinal Görüntü")

plt.subplot(1, 4, 2)
plt.imshow(filtered_image)
plt.title("Prewitt Filtresi")

plt.show()

^{Hazırlayan ve düzenleyen: Beyza Nur Türkü}

Laplacian Filtresi

Laplacian Filtresi, görüntünün ikinci türevini hesaplayarak yoğunluk değişimlerinin hızını (kenarları) vurgular. Laplacian Filtresi yön bilgisi vermez sadece yoğunluk değişimlerinin büyüklüğünü tespit eder.

def laplacian_filter(image):
  gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

  laplacian_kernel = np.array([[ 0, -1,  0],
                               [-1,  4, -1],
                              [ 0, -1,  0]], dtype=np.float32)

  height, width = gray.shape

  laplacian_result = np.zeros_like(gray, dtype=np.float32)

  padded_gray = np.pad(gray, 1, mode='constant', constant_values=0)

  for y in range(height):
        for x in range(width):
            region = padded_gray[y:y+3, x:x+3]
            laplacian_result[y, x] = np.sum(region * laplacian_kernel)

  laplacian_result = cv2.normalize(laplacian_result, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)

  return laplacian_result

image = cv2.imread('dosya_yolu', cv2.COLOR_BGR2RGB)

laplacian = laplacian_filter(image)

image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
new_image = cv2.cvtColor(laplacian, cv2.COLOR_BGR2RGB)

plt.figure(figsize=(20, 10))

plt.subplot(1, 2, 1)
plt.imshow(image)
plt.title("Orijinal Görüntü")

plt.subplot(1, 2, 2)
plt.imshow(new_image)
plt.title("Laplacian Filtresi")

plt.show()

^{Hazırlayan ve düzenleyen: Beyza Nur Türkü}

LoG (Laplacian of Gaussian) Filtresi

LoG (Laplacian of Gaussian) Filtresi, Gauss Filtresi ile Laplacian Filtresinin bir kombinasyonudur. Önce görüntü Gauss bulanıklaştırma ile yumuşatılır ardından Laplacian operatörü ile ikinci türev hesaplanarak kenar vurgulanır.

def log_filter(image):
  gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

  log_kernel = np.array([[ 0,  0, -1,  0,  0],
                            [ 0, -1, -2, -1,  0],
                            [-1, -2, 16, -2, -1],
                            [ 0, -1, -2, -1,  0],
                            [ 0,  0, -1,  0,  0]], dtype=np.float32)

  height, width = gray.shape

  log_result = np.zeros_like(gray, dtype=np.float32)

  padded_gray = np.pad(gray, 2, mode='constant', constant_values=0)

  for y in range(height):
        for x in range(width):
            region = padded_gray[y:y+5, x:x+5]
            log_result[y, x] = np.sum(region * log_kernel)

  log_result = cv2.normalize(log_result, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)

  return log_result

image = cv2.imread('dosya_yolu', cv2.COLOR_BGR2RGB)

log_filtered = log_filter(image)

image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
new_image = cv2.cvtColor(log_filtered, cv2.COLOR_BGR2RGB)

plt.figure(figsize=(20, 10))

plt.subplot(1, 2, 1)
plt.imshow(image)
plt.title("Orijinal Görüntü")

plt.subplot(1, 2, 2)
plt.imshow(new_image)
plt.title("LoG Filtresi")

plt.show()

^{Hazırlayan ve düzenleyen: Beyza Nur Türkü}

Uzamsal Filtreleme

Uzamsal Filtreleme

Temel Prensip

İşleyiş Adımları

Uzamsal Filtrelemenin Amacı

Uzamsal Filtreleme Türleri

Düşük Geçişli Filtreler (Low-Pass Filters)

Ortalama (Mean) Filtresi

Gauss (Gaussian) Filtresi

Medyan (Median) Filtresi

Minimum Filtresi

Maksimum Filtresi

Disk Filtresi

k-NN Filtresi

Yüksek Geçişli Filtreler (High-Pass Filters)

Sobel Filtresi

Prewitt Filtresi

Laplacian Filtresi

LoG (Laplacian of Gaussian) Filtresi

Kaynakça

Yazar Bilgileri

Etiketler

İçindekiler

Tartışmalar