Skip to main content

Modul teori — Deteksi tepi (gradien Roberts–Prewitt–Sobel & LoG)

Pengolahan Citra Digital (PCD), pertemuan ke-10

Deteksi tepi memunculkan lokasi transisi intensitas yang sering berkaitan dengan batas objek, teks, atau struktur bentuk. Dibanding memproses setiap piksel intensitas mentah, peta tepi (atau magnitud gradien) merangkum informasi geometri lebih ringkas dan sering dipakai sebagai jembatan menuju analisis bentuk atau keputusan sistem.

Contoh penggunaan (gambaran domain; rumus operator dan contoh numerik ada di bab berikut):

Modul ini menekankan inti matematis gradien (Roberts–Prewitt–Sobel) dan LoG; pada bagian Alur dalam sistem visi di akhir dokumen, langkah-langkah tersebut diposisikan dalam pipeline tipikal tanpa mengulang daftar aplikasi di atas.

0.1 Tujuan pembelajaran

  1. Menjelaskan tepi sebagai lokasi perubahan intensitas dan hubungannya dengan turunan pertama serta turunan kedua fungsi intensitas.
  2. Menurunkan dan memakai mask Roberts, Prewitt, dan Sobel sebagai aproksimasi gradien diskret \(G_x\), \(G_y\).
  3. Menghitung magnitud \(\|\nabla f\|\), arah gradien, serta menginterpretasikan respons operator.
  4. Menjelaskan Laplacian, Laplacian of Gaussian (LoG), peran parameter \(\sigma\), dan gagasan zero-crossing untuk deteksi tepi.
  5. Mengimplementasikan operator dengan NumPy/SciPy (ndimage.convolve, ndimage.sobel, ndimage.gaussian_laplace).

1 Model kontinu dan citra diskret

Pada domain kontinu, citra monokrom dimodelkan sebagai fungsi terbatas \(f:\Omega \subset \mathbb{R}^2 \to \mathbb{R}\) yang mulai sebagian (atau dalam praktik: mulus sebagian pada wilayah yang relevan). Tepi ideal sering dimodelkan sebagai lokasi di mana \(f\) berubah cepat; pada fungsi mulus, lokasi tersebut berkaitan dengan gradien atau turunan kedua yang besar.

Cara membaca \(f:\Omega \subset \mathbb{R}^2 \to \mathbb{R}\). Baca: “\(f\) memetakan setiap titik di bidang (dalam daerah \(\Omega\)) ke satu bilangan real (intensitas).”

  • \(f\) — nama fungsi intensitas (abu-abu) pada model kontinu.
  • \(\Omega\) — subset bidang tempat citra dianalisis (bidang gambar; bisa persegi panjang).
  • \(\subset\) — “terkandung di”; \(\Omega\) bagian dari \(\mathbb{R}^2\).
  • \(\mathbb{R}^2\) — pasangan koordinat kontinu \((x,y)\).
  • \(\to\) — “dipetakan ke”.
  • \(\mathbb{R}\) — nilai intensitas satu kanal (skalar).
  • “Terbatas / mulus sebagian” — syarat agar turunan dalam rumus gradien/Laplacian bermakna; di citra nyata kita hampiri dengan diskret.

Pada komputer, \(f\) disampling menjadi matriks \(f[i,j]\) pada grid terbatas. Turunan parsial \(\partial f/\partial x\) dan \(\partial f/\partial y\) dihampiri dengan selisih terhingga pada tetangga piksel. Operasi linear spasial yang shift-invariant pada grid dapat ditulis sebagai konvolusi diskret (atau korelasi, tergantung konvensi buku); kernel kecil \(3\times 3\) atau \(2\times 2\) memadai untuk aproksimasi orde rendah.

Cara membaca \(f[i,j]\). \(i\) biasanya indeks baris (vertikal), \(j\) indeks kolom (horizontal); \(f[i,j]\) satu bilangan intensitas di sel tersebut.

2 Konvolusi diskret dan mode batas

Konvolusi 2D (dengan kernel \(h\) berukuran terbatas):

\[ (f * h)[i,j] = \sum_{m,n} f[i-m, j-n]\, h[m,n]. \]

Cara membaca rumus konvolusi. Kiri: nilai citra hasil konvolusi di piksel baris \(i\), kolom \(j\). Kanan: jumlah semua kontribusi produk \(f\) dengan \(h\) ketika kernel digeser sehingga pusat kernel di \((i,j)\).

  • \((f*h)[i,j]\) — nilai hasil konvolusi di indeks piksel \((i,j)\).
  • \(\sum_{m,n}\) — jumlahkan untuk semua indeks \((m,n)\) yang dilalui kernel (biasanya \(|m|,|n|\) kecil).
  • \(f[i-m,j-n]\) — intensitas citra asli di lokasi yang “dijangkau” oleh elemen kernel \(h[m,n]\).
  • \(h[m,n]\) — bobot kernel pada posisi relatif \((m,n)\) terhadap acuan konvolusi.
  • \(*\) — operator konvolusi (bukan perkalian biasa).

Pada implementasi, indeks keluar dari domain citra memerlukan kebijakan batas: constant, reflect, nearest, dll. Mode reflect umum dipakai pada deteksi tepi agar artefak di tepi frame tidak terlalu besar dibanding constant (padding nol memunculkan tepi palsu).

Korelasi vs konvolusi: beberapa buku mendefinisikan “mask Sobel” sebagai korelasi; jika kernel simetris terhadap transformasi yang dipakai, hasil dapat disamakan dengan penyesuaian tanda pada kernel tidak-simetris. Yang penting: dokumentasikan apakah pustaka memakai convolve atau correlate (SciPy ndimage.convolve memakai definisi konvolusi di atas).

3 Tepi, gradien, dan turunan pertama

Gradien (vektor turunan pertama):

\[ \nabla f(x,y) = \left(f_x,\, f_y\right)^\top = \left(\frac{\partial f}{\partial x},\, \frac{\partial f}{\partial y}\right)^\top. \]

Cara membaca gradien. \(\nabla f\) dibaca “nabla \(f\)” atau “gradien \(f\)” — vektor dua komponen: laju perubahan \(f\) searah \(x\), dan laju perubahan \(f\) searah \(y\).

  • \(\nabla\) — operator nabla (kumpulan turunan parsial spasial).
  • \(f_x = \partial f/\partial x\) — turunan parsial terhadap \(x\) (perubahan intensitas sejajar sumbu \(x\)).
  • \(f_y = \partial f/\partial y\) — turunan parsial terhadap \(y\).
  • Tanda \(\top\) — transpose: vektor kolom ditulis sebagai baris demi ringkasnya di teks.
  • \((x,y)\) — koordinat kontinu pada bidang.

Magnitud gradien:

\[ \|\nabla f\| = \sqrt{f_x^2 + f_y^2}. \]

Cara membaca magnitud. \(\|\nabla f\|\) dibaca “norma (panjang) vektor gradien”: akar dari jumlah kuadrat kedua komponen turunan.

  • \(\|\cdot\|\) — norma Euklides vektor (panjang “panah” gradien).
  • \(f_x^2,\, f_y^2\) — kuadrat komponen (selalu \(\geq 0\)).
  • \(\sqrt{\cdot}\) — akar kuadrat; hasilnya \(\geq 0\), makin besar jika perubahan intensitas makin curam.

Lokasi dengan \(\|\nabla f\|\) besar berkaitan dengan perubahan intensitas dominan pada arah tegak lurus iso-intensitas. Arah gradien \(\theta = \operatorname{atan2}(f_y, f_x)\) dipakai pada non-maximum suppression (mis. Canny) untuk menipiskan tepi sepanjang arah maksimum magnitud.

Cara membaca \(\theta = \operatorname{atan2}(f_y, f_x)\). \(\operatorname{atan2}\) membaca “arkus tangen dua argumen”: sudut vektor gradien dalam radian (atau derajat setelah konversi), dengan kuadran yang benar — tidak ambigu seperti \(\arctan(f_y/f_x)\) saat \(f_x=0\).

  • \(\theta\) — arah gradien (sudut terhadap sumbu \(x\)).
  • \(f_x,\, f_y\) — komponen gradien (turunan parsial) seperti di atas.
  • Urutan argumen \((f_y, f_x)\) — konvensi banyak pustaka: \(\tan\theta = f_y/f_x\).

Norma \(L_1\) cepat: \(|f_x| + |f_y|\) sebagai pendekatan konveks.

Konvensi modul ini: indeks \(j\) menyumbu horizontal (kolom) dan \(i\) vertikal (baris). \(G_x\) dihitung dengan kernel yang membedakan sepanjang kolom; \(G_y\) sepanjang baris. Pastikan konsisten dengan ndimage.sobel(..., axis=1) untuk turunan sepanjang sumbu kedua (kolom).

4 Operator Roberts (\(2\times 2\))

Roberts memakai diferensi diagonal pada sel \(2\times 2\):

\[ G_x^{(R)} = \begin{bmatrix} +1 & 0 \\ 0 & -1 \end{bmatrix},\qquad G_y^{(R)} = \begin{bmatrix} 0 & +1 \\ -1 & 0 \end{bmatrix}. \]

Cara membaca matriks kernel Roberts. Tabel angka adalah kernel \(2\times 2\): baris dan kolom = offset relatif; angka = bobot yang dikalikan dengan piksel \(f\) di sekitar posisi pusat saat konvolusi.

  • \(G_x^{(R)},\, G_y^{(R)}\) — dua mask untuk mendekati komponen gradien (diagonal).
  • Isi \(\begin{bmatrix} \cdot & \cdot \\ \cdot & \cdot \end{bmatrix}\) — baris pertama/ke-0 sering berkaitan dengan offset baris \(-1/0\), kolom dengan offset kolom (sesuai implementasi); yang penting pola diferensi diagonal \(+1\) dan \(-1\) pada posisi berbeda.
  • Superskrip \((R)\) — “versi Roberts” untuk membedakan dari Prewitt/Sobel.

Interpretasi: sangat lokal sehingga rentan noise (varians tinggi pada turunan numerik tanpa regularisasi). Keunggulan: biaya komputasi minimal; cocok untuk perangkat sangat terbatas atau pipeline kasar.

5 Operator Prewitt (\(3\times 3\))

Aproksimasi turunan dengan pemberat rata pada arah tegak lurus diferensi (setara dengan sedikit integrasi sebelum diferensi, sehingga sedikit meredam frekuensi tinggi):

\[ G_x^{(P)} = \begin{bmatrix} -1 & 0 & +1 \\ -1 & 0 & +1 \\ -1 & 0 & +1 \end{bmatrix},\qquad G_y^{(P)} = \begin{bmatrix} -1 & -1 & -1 \\ 0 & 0 & 0 \\ +1 & +1 & +1 \end{bmatrix}. \]

Cara membaca kernel Prewitt. Matriks \(3\times 3\): baris = tiga baris piksel tetangga vertikal; kolom = tiga kolom horizontal; angka \(-1,0,+1\) adalah bobot diferensi/penjumlahan.

  • \(G_x^{(P)}\) — pola tiga kolom membedakan intensitas kiri vs kanan (turunan arah \(x\)).
  • \(G_y^{(P)}\) — pola tiga baris membedakan atas vs bawah (turunan arah \(y\)).
  • Superskrip \((P)\) — Prewitt.

Faktor skala konstan (mis. \(1/3\), \(1/6\)) sering diabaikan jika hanya ambang relatif yang dipakai pada magnitud.

6 Operator Sobel (\(3\times 3\))

Kernel Sobel memakai bobot \(1,2,1\) pada arah ortogonal diferensi — setara dengan konvolusi separable dengan kernel smoothing \([1,2,1]\) dan kernel diferensi \([-1,0,1]\) (hingga skala):

\[ G_x^{(S)} = \begin{bmatrix} -1 & 0 & +1 \\ -2 & 0 & +2 \\ -1 & 0 & +1 \end{bmatrix},\qquad G_y^{(S)} = \begin{bmatrix} -1 & -2 & -1 \\ 0 & 0 & 0 \\ +1 & +2 & +1 \end{bmatrix}. \]

Cara membaca kernel Sobel. Sama seperti Prewitt berukuran \(3\times 3\), tetapi baris/kolom pusat diberi bobot 2 agar titik pusat lebih diutamakan (setara halus ringan sebelum diferensi).

  • Angka negatif dan positif — kontribusi piksel gelap vs terang ke arah diferensi.
  • Superskrip \((S)\) — Sobel.

Dampak: sedikit penghalusan sebelum diferensi → respons noise berkurang dibanding Roberts; tepi cenderung sedikit lebih tebal dibanding Prewitt pada pengaturan yang sama.

Verifikasi: scipy.ndimage.sobel mengimplementasikan operator terkait dengan konvensi sumbu array; bandingkan dengan konvolusi manual pada contoh di bawah.

7 Ringkasan operator gradien

Operator Ukuran Regularisasi implisit Catatan
Roberts \(2\times 2\) tidak paling berisik
Prewitt \(3\times 3\) rata sederhana kompromi
Sobel \(3\times 3\) bobot triangular umum di praktik

8 Turunan kedua dan Laplacian

Laplacian (operator turunan kedua isotropik):

\[ \nabla^2 f = \frac{\partial^2 f}{\partial x^2} + \frac{\partial^2 f}{\partial y^2}. \]

Cara membaca Laplacian. \(\nabla^2\) dibaca “operator Laplacian” atau “nabla kuadrat”: jumlah turunan kedua searah \(x\) dan searah \(y\).

  • \(\partial^2 f/\partial x^2\) — “seberapa melengkung” grafik intensitas sepanjang \(x\) (turunan kedua).
  • \(\partial^2 f/\partial y^2\) — sama sepanjang \(y\).
  • \(\nabla^2 f\) — skalar di setiap titik; nilai besar mutlak ⟺ variasi intensitas sangat tidak-linear secara lokal.

Pada citra mulus, maksimum \(|f_x|\) di sepanjang tepi sering berkaitan dengan titik di mana turunan kedua melewati pola tertentu; Laplacian peka terhadap titik isolasi dan noise karena turunan kedua memperkuat frekuensi tinggi.

Diskret orde-2 klasik (empat tetangga):

\[ \nabla^2 f \approx f[i-1,j] + f[i+1,j] + f[i,j-1] + f[i,j+1] - 4f[i,j]. \]

Cara membaca aproksimasi diskret. \(f[i,j]\) = intensitas di baris \(i\), kolom \(j\); empat tetangga langsung (atas/bawah/kiri/kanan) dijumlahkan; pusat dikurangi empat kali nilai pusat — pola “bintang” klasik Laplacian 4-tetangga.

  • \(f[i\pm 1,j],\, f[i,j\pm 1]\) — piksel tetangga ortogonal.
  • \(-4f[i,j]\) — bobot pusat agar area konstan menghasilkan nol (tidak ada tepi).

Varian delapan tetangga memasukkan diagonal dengan bobot berbeda (lihat Gonzalez & Woods).

9 Laplacian of Gaussian (LoG)

Langkah Gaussian (low-pass) sebelum Laplacian meredam noise sebelum penguatan frekuensi tinggi oleh Laplacian:

\[ \text{LoG}_\sigma(f) = \nabla^2 \bigl( G_\sigma * f \bigr), \]

dengan \(G_\sigma\) kernel Gaussian isotropik parameter skala \(\sigma\). Sifat konvolusi linear dan derivasi:

\[ \nabla^2 (G_\sigma * f) = (\nabla^2 G_\sigma) * f, \]

Cara membaca dua rumus LoG di atas. Baris pertama: “ambil citra \(f\), haluskan dengan Gaussian \(G_\sigma\), lalu terapkan Laplacian.” Baris kedua (sifat matematis): “Laplacian dari (Gaussian konvolusi \(f\)) sama dengan (Laplacian dari Gaussian itu sendiri) dikonvolusikan dengan \(f\)” — sehingga bisa dihitung satu kali konvolusi dengan kernel tetap \(\nabla^2 G_\sigma\).

  • \(\text{LoG}_\sigma(f)\) — respons operator LoG pada \(f\) dengan parameter lebar blur \(\sigma\) (standar deviasi Gaussian).
  • \(G_\sigma\) — kernel/fungsi Gaussian 2D isotropik berparameter \(\sigma\) (mak besar \(\sigma\) → blur makin lebar).
  • \(\nabla^2(\cdot)\) — Laplacian (turunan kedua spasial) dari fungsi di dalam tanda kurung.
  • \(*\) — konvolusi (sama konvensi seperti di bagian konvolusi diskret).
  • \(\nabla^2 G_\sigma\) — “topi Meksiko”: kernel tunggal yang menyatukan blur + Laplacian dalam satu mask.

sehingga LoG setara dengan satu konvolusi dengan kernel \(\nabla^2 G_\sigma\) (2D “topi Meksiko”). Parameter \(\sigma\) mengontrol lebar pita frekuensi yang dihilangkan: \(\sigma\) besar → lebih halus → tepi lebih “kasar” secara spasial; \(\sigma\) kecil → lebih sensitif pada detail halus dan noise.

Deteksi tepi Marr–Hildreth (gambaran): cari lokasi zero-crossing dari \(\text{LoG}_\sigma(f)\), yaitu piksel di mana tanda Laplacian berubah di antara tetangga yang relevan, sering disertai syarat kemiringan cukup agar tidak memunculkan garis nol palsu dari noise. Implementasi penuh melibatkan interpolasi subpiksel, ambang kemiringan, dan penautan kurva — di luar cakupan satu modul; di bawah kita visualisasi respons LoG dan petunjuk zero-crossing sederhana.

10 Perbandingan gradien (turunan pertama) vs LoG

Aspek Gradien (Roberts, Prewitt, Sobel) LoG
Orde turunan pertama kedua (setelah blur-Gaussian)
Keluaran utama magnitud (dan arah) respons berosilasi di sekitar tepi
Lokasi tepi puncak/ambang magnitud zero-crossing
Sensitivitas noise tinggi untuk kernel kecil dapat dikendalikan lewat \(\sigma\)
Biaya rendah–sedang sedang (lebar kernel efektif ~\(6\sigma\))

11 Contoh 1: citra uji ascent

Potongan citra ascent (SciPy) dinormalisasi ke \([0,1]\); respons gradien dan LoG dihitung dengan reflect.

import matplotlib

matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
from scipy import ndimage

try:
    from scipy.datasets import ascent

    f0 = ascent().astype(np.float64)
except ImportError:
    x = np.linspace(0, 4 * np.pi, 512)
    y = np.linspace(0, 4 * np.pi, 512)[:, None]
    f0 = np.clip(120 + 80 * np.sin(x) * np.cos(y * 0.7), 0, 255).astype(np.float64)

f = f0[120:392, 128:400]
f = (f - f.min()) / (f.max() - f.min() + 1e-9)

sx = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], dtype=np.float64)
sy = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]], dtype=np.float64)
gx = ndimage.convolve(f, sx, mode="reflect")
gy = ndimage.convolve(f, sy, mode="reflect")
mag = np.hypot(gx, gy)

sig = 1.2
log = ndimage.gaussian_laplace(f, sigma=sig)


def zero_cross_4nb(L):
    z = np.zeros_like(L, dtype=bool)
    z[1:-1, 1:-1] = (
        (np.sign(L[1:-1, 1:-1]) != np.sign(L[:-2, 1:-1]))
        | (np.sign(L[1:-1, 1:-1]) != np.sign(L[2:, 1:-1]))
        | (np.sign(L[1:-1, 1:-1]) != np.sign(L[1:-1, :-2]))
        | (np.sign(L[1:-1, 1:-1]) != np.sign(L[1:-1, 2:]))
    )
    return z.astype(np.float64)


zp = zero_cross_4nb(log)


def n01(a):
    a = np.asarray(a, dtype=np.float64)
    a = a - a.min()
    return a / (a.max() + 1e-9)


fig, axes = plt.subplots(1, 4, figsize=(13, 3.2))
axes[0].imshow(f, cmap="gray")
axes[0].set_title("Asli")
axes[1].imshow(n01(mag), cmap="magma")
axes[1].set_title("|∇f| Sobel")
axes[2].imshow(log, cmap="RdBu_r", vmin=-0.08, vmax=0.08)
axes[2].set_title(rf"LoG ($\sigma$={sig})")
axes[3].imshow(zp.astype(float), cmap="gray_r")
axes[3].set_title("Zero-cross (4-nb)")
for ax in axes:
    ax.axis("off")
plt.suptitle("Contoh: ascent", fontsize=11, y=1.05)
plt.tight_layout()
fig
Gambar 1: ascent (crop): asli, magnitud Sobel, respons LoG (\(\sigma=1.2\)), dan petunjuk zero-crossing (perubahan tanda pada tetangga 4).

12 Contoh 2: citra face (luminansi)

Citra wajah (scipy.datasets.face) dikonversi ke grayscale dengan koefisien ITU-R BT.601 (\(0.299R + 0.587G + 0.114B\)), lalu dipotong untuk fokus pada detail wajah. Perbandingan yang sama menunjukkan bahwa tekstur halus (rambut, pola kulit) menghasilkan respons gradien yang lebih “padat”, sedangkan LoG dengan \(\sigma\) sedang menonjolkan struktur skala menengah.

import matplotlib

matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
from scipy import ndimage

def _synthetic_luma_face(h=640, w=800):
    """Pengganti deterministik bila `scipy.datasets.face` tidak tersedia (mis. tanpa pooch)."""
    rng = np.random.default_rng(42)
    yy, xx = np.mgrid[0:h, 0:w].astype(np.float64)
    cy, cx = 0.42 * h, 0.48 * w
    yn, xn = (yy - cy) / (0.32 * h), (xx - cx) / (0.28 * w)
    g = np.exp(-((yn**2 + xn**2) ** 1.35))
    g = g + 0.18 * np.sin(0.07 * (xx + yy)) + 0.05 * rng.standard_normal((h, w))
    g = g + 0.12 * np.sin(0.12 * yy) * np.exp(-((xx - cx) ** 2) / ((0.11 * w) ** 2 + 1e-9))
    g = np.clip(g, 0, None)
    return (g - g.min()) / (g.max() - g.min() + 1e-9)


g = None
try:
    from scipy.datasets import face

    rgb = face()
    g = 0.299 * rgb[:, :, 0] + 0.587 * rgb[:, :, 1] + 0.114 * rgb[:, :, 2]
except ImportError:
    try:
        from scipy.datasets import ascent

        a = ascent().astype(np.float64)
        if a.shape[0] >= 620 and a.shape[1] >= 780:
            g = a
        else:
            g = None
    except ImportError:
        g = None
if g is None:
    g = (_synthetic_luma_face() * 255.0).astype(np.float64)

g = g[200:620, 280:780]
g = (g - g.min()) / (g.max() - g.min() + 1e-9)

sx = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], dtype=np.float64)
sy = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]], dtype=np.float64)
mag = np.hypot(
    ndimage.convolve(g, sx, mode="reflect"),
    ndimage.convolve(g, sy, mode="reflect"),
)

sig = 1.5
log = ndimage.gaussian_laplace(g, sigma=sig)


def zero_cross_4nb(L):
    z = np.zeros_like(L, dtype=bool)
    z[1:-1, 1:-1] = (
        (np.sign(L[1:-1, 1:-1]) != np.sign(L[:-2, 1:-1]))
        | (np.sign(L[1:-1, 1:-1]) != np.sign(L[2:, 1:-1]))
        | (np.sign(L[1:-1, 1:-1]) != np.sign(L[1:-1, :-2]))
        | (np.sign(L[1:-1, 1:-1]) != np.sign(L[1:-1, 2:]))
    )
    return z.astype(np.float64)


zp = zero_cross_4nb(log)


def n01(a):
    a = np.asarray(a, dtype=np.float64)
    a = a - a.min()
    return a / (a.max() + 1e-9)


fig, axes = plt.subplots(1, 4, figsize=(13, 3.2))
axes[0].imshow(g, cmap="gray")
axes[0].set_title("Asli (face)")
axes[1].imshow(n01(mag), cmap="magma")
axes[1].set_title("|∇f| Sobel")
axes[2].imshow(log, cmap="RdBu_r", vmin=-0.05, vmax=0.05)
axes[2].set_title(rf"LoG ($\sigma$={sig})")
axes[3].imshow(zp.astype(float), cmap="gray_r")
axes[3].set_title("Zero-cross (4-nb)")
for ax in axes:
    ax.axis("off")
plt.suptitle("Contoh: face (luminansi)", fontsize=11, y=1.05)
plt.tight_layout()
fig
Gambar 2: face (crop, luminansi): asli, Sobel, LoG (\(\sigma=1.5\)), zero-cross 4-tetangga.

13 Panel perbandingan operator gradien (verifikasi Sobel)

import matplotlib

matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
from scipy import ndimage

try:
    from scipy.datasets import ascent

    f0 = ascent().astype(np.float64)
except ImportError:
    x = np.linspace(0, 4 * np.pi, 512)
    y = np.linspace(0, 4 * np.pi, 512)[:, None]
    f0 = np.clip(120 + 80 * np.sin(x) * np.cos(y * 0.7), 0, 255).astype(np.float64)

f = f0[120:392, 128:400]
f = (f - f.min()) / (f.max() - f.min() + 1e-9)

rx = np.array([[1.0, 0.0], [0.0, -1.0]])
ry = np.array([[0.0, 1.0], [-1.0, 0.0]])
px = np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]], dtype=np.float64)
py = np.array([[-1, -1, -1], [0, 0, 0], [1, 1, 1]], dtype=np.float64)
sx = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], dtype=np.float64)
sy = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]], dtype=np.float64)


def mag(gx, gy):
    return np.hypot(gx, gy)


def nshow(a):
    a = np.asarray(a, dtype=np.float64)
    a = a - a.min()
    return a / (a.max() + 1e-9)


mr = mag(ndimage.convolve(f, rx, mode="reflect"), ndimage.convolve(f, ry, mode="reflect"))
mp = mag(ndimage.convolve(f, px, mode="reflect"), ndimage.convolve(f, py, mode="reflect"))
ms = mag(ndimage.convolve(f, sx, mode="reflect"), ndimage.convolve(f, sy, mode="reflect"))

gx_sp = ndimage.sobel(f, axis=1)
gy_sp = ndimage.sobel(f, axis=0)
ms_api = np.hypot(gx_sp, gy_sp)

fig, axes = plt.subplots(2, 3, figsize=(11, 5.2))
axes[0, 0].imshow(f, cmap="gray")
axes[0, 0].set_title("Asli")
axes[0, 1].imshow(nshow(mr), cmap="magma")
axes[0, 1].set_title("|∇f| Roberts")
axes[0, 2].imshow(nshow(mp), cmap="magma")
axes[0, 2].set_title("|∇f| Prewitt")
axes[1, 0].imshow(nshow(ms), cmap="magma")
axes[1, 0].set_title("|∇f| Sobel (manual)")
axes[1, 1].imshow(nshow(ms_api), cmap="magma")
axes[1, 1].set_title("|∇f| Sobel (ndimage)")
axes[1, 2].imshow(nshow(np.abs(ms - ms_api)), cmap="viridis")
axes[1, 2].set_title("|manual − ndimage|")
for ax in axes.ravel():
    ax.axis("off")
plt.suptitle("Perbandingan operator gradien", fontsize=12, y=1.02)
plt.tight_layout()
fig
Gambar 3: Satu crop ascent: Roberts, Prewitt, Sobel manual vs ndimage.sobel, dan |selisih|.

14 LoG pada dua nilai \(\sigma\)

import matplotlib

matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
from scipy import ndimage

try:
    from scipy.datasets import ascent

    f0 = ascent().astype(np.float64)
except ImportError:
    x = np.linspace(0, 4 * np.pi, 512)
    y = np.linspace(0, 4 * np.pi, 512)[:, None]
    f0 = np.clip(120 + 80 * np.sin(x) * np.cos(y * 0.7), 0, 255).astype(np.float64)

f = f0[120:392, 128:400]
f = (f - f.min()) / (f.max() - f.min() + 1e-9)

fig, axes = plt.subplots(1, 3, figsize=(10, 3.2))
axes[0].imshow(f, cmap="gray")
axes[0].set_title("Asli")
for ax, sig in zip(axes[1:], [0.8, 2.0]):
    L = ndimage.gaussian_laplace(f, sigma=sig)
    ax.imshow(L, cmap="RdBu_r", vmin=-0.06, vmax=0.06)
    ax.set_title(rf"LoG $\sigma$={sig}")
    ax.axis("off")
axes[0].axis("off")
plt.suptitle("Pengaruh skala σ pada LoG", fontsize=11, y=1.05)
plt.tight_layout()
fig
Gambar 4: ascent crop: LoG untuk \(\sigma=0.8\) vs \(\sigma=2.0\) (skala warna sama per baris relatif).

15 Visual kernel Sobel

import matplotlib

matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np

sx = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], dtype=np.float64)
sy = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]], dtype=np.float64)
fig, axes = plt.subplots(1, 2, figsize=(5, 2.2))
for ax, k, t in zip(axes, [sx, sy], [r"Sobel $G_x$", r"Sobel $G_y$"]):
    ax.imshow(k, cmap="RdBu_r", vmin=-2, vmax=2)
    ax.set_title(t)
    ax.set_xticks(range(3))
    ax.set_yticks(range(3))
plt.tight_layout()
fig
Gambar 5: Kernel Sobel \(G_x\) dan \(G_y\).

16 Alur dalam sistem visi

Berikut urutan operasional yang melanjutkan pengantar: fokus pada penyisipan gradien dan LoG dalam pipeline, bukan daftar aplikasi.

  1. Pra-pemrosesan: koreksi radiometrik, denoise ringan jika perlu.
  2. Deteksi tepi gradien: \(G_x, G_y\) → \(M\), \(\theta\) → ambang / NMS / hysteresis (Canny).
  3. Alternatif LoG: pilih \(\sigma\) → hitung LoG → zero-crossing + filter kemiringan → kurva tepi.
  4. Pasca: penautan kontur, deskriptor bentuk, atau masukan ke segmentasi.

17 Latihan mandiri

  1. Buktikan secara skematik mengapa faktor skala positif yang sama pada \(G_x\) dan \(G_y\) tidak mengubah arah gradien, hanya magnitud.
  2. Jelaskan secara kualitatif mengapa \(\sigma\) besar pada LoG menghasilkan respons yang lebih “kasar” secara spasial pada citra face.
  3. Rancang contoh \(1\)D (sinyal segmen konstan + anak tangga) dan jelaskan bentuk turunan pertama vs turunan kedua di sekitar transisi.
  4. Bandingkan kompleksitas: mengapa zero-crossing LoG umumnya memerlukan aturan tambahan dibanding ambang sederhana pada magnitud Sobel?
  5. Cari di dokumentasi SciPy definisi gaussian_laplace terhadap normalisasi Gaussian dan tandai implikasinya pada skala nilai LoG.

18 Referensi