Modul teori — Segmentasi warna & analisis tekstur (GLCM)
Pengolahan Citra Digital (PCD), pertemuan ke-13
Modul ini melanjutkan segmentasi threshold (PCD 12): bila intensitas abu-abu saja tidak membedakan objek (warna berbeda tetapi luminansi sama, atau sebaliknya), kita memakai kesamaan warna; bila intensitas/warna mirip tetapi pola permukaan berbeda, kita memakai tekstur — salah satu deskriptor klasiknya adalah GLCM (Gray-Level Co-occurrence Matrix, matriks ko-okurensi tingkat abu-abu).
Contoh penggunaan:
- Pertanian & remote sensing: memisahkan vegetasi, tanah, dan air dari citra multiband atau RGB drone.
- Industri makanan: sortir buah berdasarkan warna kematangan (ruang HSV/Lab) dan tekstur kulit (GLCM).
- Patologi / mikroskop: wilayah jaringan dengan tekstur kasar vs halus pada citra grayscale H&E.
- Pengawasan: region dengan tekstur jalan vs semak berdasarkan kontras GLCM lokal.
Alur modul: ruang warna & metrik kesamaan → segmentasi warna (K-means, ambang jarak, region growing) → GLCM & fitur Haralick → segmentasi berbasis tekstur (jendela lokal).
0.1 Tujuan pembelajaran
- Menjelaskan batas threshold intensitas (PCD 12) dan kapan warna atau tekstur diperlukan.
- Membedakan ruang warna RGB, HSV, dan gambaran Lab; memilih metrik jarak warna yang sesuai.
- Menerapkan segmentasi kesamaan warna: K-means, ambang jarak, dan region growing berbasis warna.
- Mendefinisikan GLCM \(P(i,j \mid d,\theta)\), parameter \(d\) dan \(\theta\), serta normalisasi matriks.
- Menghitung fitur tekstur Haralick (kontras, homogenitas, energi, korelasi, entropi) dari GLCM.
- Menyusun segmentasi berbasis tekstur dengan jendela lokal dan ambang fitur GLCM.
- Mengimplementasikan contoh dengan NumPy (dan opsional
skimage.feature.graycomatrix).
1 Dari intensitas ke warna dan tekstur
PCD 12 memisahkan piksel berdasarkan satu kanal intensitas \(f[i,j]\). Dua kegagalan umum:
| Fenomena | Mengapa threshold gagal | Arah solusi |
|---|---|---|
| Warna berbeda, luminansi sama | \(f\) abu-abu hampir identik | segmentasi di ruang warna (RGB, HSV, Lab) |
| Warna/intensitas mirip, pola berbeda | histogram global serupa | fitur tekstur (GLCM, dll.) |
Tekstur menggambarkan variasi intensitas spasial berulang atau statistik tetangga — bukan nilai piksel tunggal, melainkan hubungan pasangan intensitas pada jarak dan arah tertentu. GLCM merangkum hubungan itu dalam matriks.
2 Ruang warna dan jarak
Citra warna: \(\mathbf{c}[i,j] = (R,G,B)\) atau vektor di ruang lain. Kesamaan warna memakai jarak \(\|\mathbf{c}_1 - \mathbf{c}_2\|\) — pilihan ruang menentukan apakah jarak sesuai persepsi manusia.
2.1 RGB
Kanal \(R,G,B \in [0,255]\) (atau \([0,1]\)). Jarak Euklides:
\[ d_{\text{RGB}} = \sqrt{(R_1-R_2)^2 + (G_1-G_2)^2 + (B_1-B_2)^2}. \]
Cara membaca. Mengukur perbedaan campuran kanal; sensitif terhadap pencahayaan (semua kanal naik/turun bersama).
2.2 HSV (Hue, Saturation, Value)
Transformasi non-linear dari RGB; Hue \(H\) = sudut warna (derajat atau \([0,1]\)), Saturation \(S\) = “kemurnian” warna, Value \(V\) = terang gelap (maks kanal RGB). Segmentasi berdasarkan warna murni sering memakai \(H\) (dan \(S\)) karena \(V\) mirip luminansi.
Ambang “warna serupa”: \(|H_1 - H_2| < \tau_H\) dengan koreksi sirkular (jarak di lingkaran hue — merah \(0°\) dekat \(360°\)).
2.3 Lab (gambaran)
$ L^* $ mendekati luminansi perseptual; \(a^*, b^*\) sumbu hijau–merah dan biru–kuning. Jarak \(\Delta E\) (mis. \(\Delta E_{76}\)) dirancang agar lebih selaras persepsi; umum di industri dan sortir produk.
2.4 Ringkasan pemilihan ruang
| Ruang | Cocok untuk | Perhatian |
|---|---|---|
| RGB | implementasi cepat, jarak sederhana | sensitif iluminasi |
| HSV | segmentasi “warna” (daun, buah, peta) | nilai \(H\) tidak stabil saat \(S \approx 0\) |
| Lab / \(\Delta E\) | kesamaan perseptual | perlu konversi dari RGB |
3 Segmentasi berbasis kesamaan warna
3.1 K-means pada vektor warna
Setiap piksel = titik \(\mathbf{c}_i \in \mathbb{R}^3\). K-means mempartisi menjadi \(K\) kelompok dengan centroid \(\boldsymbol{\mu}_k\):
\[ \min_{\{\boldsymbol{\mu}_k\}} \sum_i \bigl\| \mathbf{c}_i - \boldsymbol{\mu}_{\ell(i)} \bigr\|^2, \]
\(\ell(i)\) = indeks kelompok terdekat. Hasil: label \(L[i,j] \in \{0,\ldots,K-1\}\) — segmentasi warna tanpa ambang manual per kanal.
Kelebihan: otomatis, \(K\) kelas warna. Kekurangan: \(K\) harus ditentukan; sensitif inisialisasi; tidak eksplisit ruang HSV/Lab kecuali kita transformasi dulu.
3.2 Ambang jarak warna
Diberikan warna acuan \(\mathbf{c}_{\text{ref}}\) (dari klik pengguna atau sampel):
\[ L[i,j] = 1 \quad \text{jika } \|\mathbf{c}[i,j] - \mathbf{c}_{\text{ref}}\| < \tau. \]
Cocok untuk satu objek berwarna homogen; \(\tau\) mengontrol toleransi.
3.3 Region growing berbasis warna
Algoritme pertumbuhan wilayah dari seed \((i_0,j_0)\):
- Inisialisasi antrian dengan seed; \(\mathcal{R} = \{(i_0,j_0)\}\).
- Ambil piksel dari antrian; untuk setiap tetangga \((u,v)\) belum dilabel:
- jika \(\|\mathbf{c}[u,v] - \bar{\mathbf{c}}_{\mathcal{R}}\| < \tau\) (atau \(|H - H_0| < \tau_H\)), tambahkan ke \(\mathcal{R}\) dan antrian.
- Ulangi hingga antrian kosong.
Kesamaan warna lokal — lebih halus dari K-means global bila objek terhubung dan warna gradual; rentan leaking bila \(\tau\) terlalu besar.
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
try:
from scipy.datasets import face
rgb = face().astype(np.float64) / 255.0
except ImportError:
rng = np.random.default_rng(0)
rgb = rng.random((768, 1024, 3))
rgb = rgb[230:530, 280:680]
def kmeans_color(img, K=4, iters=15, seed=0):
rng = np.random.default_rng(seed)
h, w, _ = img.shape
X = img.reshape(-1, 3)
cent = X[rng.choice(X.shape[0], K, replace=False)]
for _ in range(iters):
dist2 = ((X[:, None, :] - cent[None, :, :]) ** 2).sum(axis=2)
labels = dist2.argmin(axis=1)
for k in range(K):
m = labels == k
if m.any():
cent[k] = X[m].mean(axis=0)
seg = cent[labels].reshape(h, w, 3)
return labels.reshape(h, w), seg
labels, seg = kmeans_color(rgb, K=4)
cmap = plt.cm.tab10(np.linspace(0, 0.9, 4))
overlay = rgb.copy()
for k in range(4):
m = labels == k
overlay[m] = overlay[m] * 0.5 + cmap[k, :3] * 0.5
fig, axes = plt.subplots(1, 3, figsize=(11, 3.5))
axes[0].imshow(rgb)
axes[0].set_title("Asli")
axes[0].axis("off")
axes[1].imshow(seg)
axes[1].set_title("K-means ($K=4$)")
axes[1].axis("off")
axes[2].imshow(np.clip(overlay, 0, 1))
axes[2].set_title("Overlay")
axes[2].axis("off")
plt.suptitle("Segmentasi kesamaan warna — K-means", fontsize=11, y=1.05)
plt.tight_layout()
fig
face (RGB): asli, K-means (\(K=4\)) di RGB, overlay label warna.
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
from collections import deque
h, w = 160, 240
rgb = np.zeros((h, w, 3))
rgb[:, : w // 2] = [0.18, 0.58, 0.30]
rgb[:, w // 2 :] = [0.55, 0.42, 0.22]
rgb[40:120, 60:150] = [0.12, 0.48, 0.22]
def rgb_to_hsv(rgb_img):
rgb_img = np.clip(rgb_img, 0, 1)
r, g, b = rgb_img[..., 0], rgb_img[..., 1], rgb_img[..., 2]
mx, mn = rgb_img.max(axis=-1), rgb_img.min(axis=-1)
v, d = mx, mx - mn
s = np.where(mx > 1e-9, d / mx, 0.0)
h_out = np.zeros_like(v)
mask = d > 1e-9
idx = np.argmax(rgb_img, axis=-1)
h_out = np.where(mask & (idx == 0), ((g - b) / d) % 6, h_out)
h_out = np.where(mask & (idx == 1), (b - r) / d + 2, h_out)
h_out = np.where(mask & (idx == 2), (r - g) / d + 4, h_out)
return ((h_out / 6) % 1.0), s, v
H, S, V = rgb_to_hsv(rgb)
seed = (80, 95)
tau = 0.08
h0 = H[seed]
visited = np.zeros((h, w), dtype=bool)
region = np.zeros((h, w), dtype=bool)
q = deque([seed])
visited[seed] = True
while q:
i, j = q.popleft()
region[i, j] = True
for di, dj in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
ni, nj = i + di, j + dj
if 0 <= ni < h and 0 <= nj < w and not visited[ni, nj]:
dh = min(abs(H[ni, nj] - h0), 1 - abs(H[ni, nj] - h0))
if dh < tau and S[ni, nj] > 0.15:
visited[ni, nj] = True
q.append((ni, nj))
fig, axes = plt.subplots(1, 2, figsize=(8.5, 3.4))
axes[0].imshow(rgb)
axes[0].plot(seed[1], seed[0], "r*", markersize=12)
axes[0].set_title("Seed (bintang merah)")
axes[0].axis("off")
axes[1].imshow(region, cmap="Greens", alpha=0.85)
axes[1].imshow(rgb, alpha=0.35)
axes[1].set_title(r"Region growing ($\tau_H$)")
axes[1].axis("off")
plt.suptitle("Kesamaan warna lokal — region growing", fontsize=11, y=1.03)
plt.tight_layout()
fig
4 Tekstur dan GLCM
4.1 Apa yang dimodelkan?
Tekstur = pola statistik/spasial intensitas: halus (variansi kecil antar tetangga), kasar (perubahan besar), berorientasi (garis/segitiga berulang). GLCM tidak menyimpan bentuk geometri eksplisit, melainkan distribusi pasangan \((k_1, k_2)\) intensitas pada offset tertentu.
4.2 Definisi GLCM
Citra kuantisasi ke \(L\) level: \(g[i,j] \in \{0,\ldots,L-1\}\). Untuk jarak \(d\) dan arah \(\theta\), offset \((\Delta i, \Delta j)\) dari sudut (mis. \(\theta=0°\): \((0,d)\) horizontal). Matriks ko-okurensi:
\[ P(i,j \mid d,\theta) = \#\bigl\{ ((r,c),(u,v)) : g[r,c]=i,\, g[u,v]=j,\, (u,v)=(r,c)+(\Delta i,\Delta j) \bigr\} \]
Normalisasi: \(p(i,j) = P(i,j) / \sum_{a,b} P(a,b)\) sehingga \(\sum_{i,j} p(i,j)=1\).
Cara membaca. Entri \(p(i,j)\) = probabilitas piksel bernilai \(i\) berpasangan dengan piksel bernilai \(j\) pada relasi spasial \((d,\theta)\). Matriks \(L \times L\) — baris/kolom = level abu-abu.
4.3 Parameter \(d\) dan \(\theta\)
| Parameter | Makna |
|---|---|
| \(d\) | jarak piksel pasangan (1 = tetangga langsung) |
| \(\theta\) | orientasi: \(0°, 45°, 90°, 135°\) umum (4 GLCM diseragamkan/di-rata) |
Tekstur berarah (mis. garis vertikal) menghasilkan GLCM berbeda untuk \(\theta=0°\) vs \(90°\). Praktik: hitung fitur untuk beberapa \(\theta\) lalu gabungkan (mean/max).
4.4 Kuantisasi level \(L\)
Citra 8-bit (\(256\) level) membuat GLCM \(256\times256\) jarang dan berisik. Umum: kuantisasi ke \(L=8,\ldots,32\) sebelum GLCM.
5 Fitur tekstur Haralick dari GLCM
Dari matriks normalisasi \(p(i,j)\), \(i,j \in \{0,\ldots,L-1\}\):
Mean baris/kolom:
\[ \mu_i = \sum_i i \sum_j p(i,j), \quad \mu_j = \sum_j j \sum_i p(i,j). \]
Kontras (variansi pasangan):
\[ \text{Contrast} = \sum_{i,j} (i-j)^2\, p(i,j). \]
Homogenitas (inverse difference moment):
\[ \text{Homogeneity} = \sum_{i,j} \frac{p(i,j)}{1 + |i-j|}. \]
Energi (ASM):
\[ \text{Energy} = \sum_{i,j} p(i,j)^2. \]
Entropi:
\[ \text{Entropy} = -\sum_{i,j} p(i,j)\, \log\bigl(p(i,j)+\epsilon\bigr). \]
Korelasi (dengan \(\sigma_i,\sigma_j\) simpangan baku marginal):
\[ \text{Correlation} = \sum_{i,j} \frac{(i-\mu_i)(j-\mu_j)\, p(i,j)}{\sigma_i \sigma_j}. \]
| Fitur | Tinggi bila… | Interpretasi kasar |
|---|---|---|
| Kontras | pasangan jauh di matriks | tekstur kasar / tepi dalam patch |
| Homogenitas | massa di diagonal \(i \approx j\) | tekstur halus, area seragam |
| Energi | satu/t sedikit entri dominan | teratur, repetitif |
| Entropi | sebar merata | acak, kompleks |
| Korelasi | ketergantungan linear \(i\)–\(j\) | pola berorientasi |
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(8)
L = 8
h, w = 80, 80
smooth = np.clip(100 + rng.normal(0, 6, (h, w)), 0, 255)
xx = np.tile(np.arange(w), (h, 1))
rough = np.clip(120 + 40 * np.sin(0.7 * xx) + rng.normal(0, 5, (h, w)), 0, 255)
def quantize(img, L=8):
return np.clip((img / 256 * L).astype(np.int32), 0, L - 1)
def glcm_matrix(g, L=8, dx=1, dy=0):
pairs = []
if dx == 1 and dy == 0:
a, b = g[:, :-1].ravel(), g[:, 1:].ravel()
elif dx == 0 and dy == 1:
a, b = g[:-1, :].ravel(), g[1:, :].ravel()
else:
a, b = g[:-1, :-1].ravel(), g[1:, 1:].ravel()
P = np.bincount(a * L + b, minlength=L * L).reshape(L, L).astype(np.float64)
return P / (P.sum() + 1e-12)
def haralick(P):
L = P.shape[0]
ii, jj = np.meshgrid(np.arange(L), np.arange(L), indexing="ij")
contrast = ((ii - jj) ** 2 * P).sum()
homogeneity = (P / (1 + np.abs(ii - jj))).sum()
energy = (P**2).sum()
entropy = -(P * np.log(P + 1e-12)).sum()
return contrast, homogeneity, energy, entropy
fig, axes = plt.subplots(2, 3, figsize=(10, 5.5))
for row, (img, name) in enumerate([(smooth, "Halus"), (rough, "Kasar")]):
g = quantize(img, L)
P = glcm_matrix(g, L)
c, hom, en, ent = haralick(P)
axes[row, 0].imshow(img, cmap="gray", vmin=0, vmax=255)
axes[row, 0].set_title(name)
axes[row, 0].axis("off")
axes[row, 1].imshow(P, cmap="Blues")
axes[row, 1].set_title("GLCM $p(i,j)$")
axes[row, 1].set_xlabel("$j$")
axes[row, 1].set_ylabel("$i$")
axes[row, 2].axis("off")
axes[row, 2].text(
0.1,
0.55,
f"Kontras = {c:.3f}\nHomogenitas = {hom:.3f}\nEnergi = {en:.3f}\nEntropi = {ent:.3f}",
fontsize=11,
va="center",
family="monospace",
)
plt.suptitle("GLCM & fitur Haralick — perbandingan tekstur", fontsize=12, y=1.02)
plt.tight_layout()
fig
6 Segmentasi berbasis tekstur (GLCM lokal)
Pola umum:
- Kuantisasi citra grayscale ke \(L\) level.
- Untuk setiap piksel (atau pusat jendela \(w \times w\)), hitung GLCM pada patch dan ekstrak fitur (mis. kontras).
- Ambang pada fitur: \(L[i,j]=1\) jika \(\text{Contrast}[i,j] > \tau\) (tekstur kasar).
Ini analog threshold PCD 12, tetapi pada fitur tekstur, bukan intensitas mentah. Alternatif: K-means pada vektor fitur \((\text{Contrast}, \text{Homogeneity}, \ldots)\) per jendela.
Biaya: per piksel perlu patch → \(O(N w^2)\); gunakan \(w\) moderat (9–25) dan \(L\) kecil.
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(2)
h, w = 180, 300
xx = np.tile(np.arange(w), (h, 1))
gray = np.zeros((h, w))
gray[:, : w // 2] = 110 + rng.normal(0, 5, (h, w // 2))
gray[:, w // 2 :] = 110 + 38 * np.sin(0.5 * xx[:, w // 2 :]) + rng.normal(0, 4, (h, w // 2))
gray = np.clip(gray, 0, 255)
L, win = 8, 19
pad = win // 2
def quantize(img, L=8):
return np.clip((img / 256 * L).astype(np.int32), 0, L - 1)
def contrast_at(q, L, win, i, j):
patch = q[i : i + win, j : j + win]
a, b = patch[:, :-1].ravel(), patch[:, 1:].ravel()
P = np.bincount(a * L + b, minlength=L * L).reshape(L, L).astype(np.float64)
s = P.sum()
if s == 0:
return 0.0
P /= s
ii, jj = np.meshgrid(np.arange(L), np.arange(L), indexing="ij")
return float(((ii - jj) ** 2 * P).sum())
q = quantize(gray, L)
qp = np.pad(q, pad, mode="reflect")
C = np.zeros_like(gray, dtype=np.float64)
for i in range(gray.shape[0]):
for j in range(gray.shape[1]):
C[i, j] = contrast_at(qp, L, win, i, j)
mask = C > np.percentile(C, 60)
fig, axes = plt.subplots(1, 4, figsize=(12, 3.2))
axes[0].imshow(gray, cmap="gray", vmin=0, vmax=255)
axes[0].set_title("Asli")
axes[0].axis("off")
axes[1].imshow(C, cmap="magma")
axes[1].set_title("Kontras GLCM lokal")
axes[1].axis("off")
axes[2].imshow(mask, cmap="gray_r")
axes[2].set_title("Mask tekstur kasar")
axes[2].axis("off")
overlay = np.stack([gray / 255] * 3, axis=-1)
overlay[mask] = [0.9, 0.2, 0.2]
axes[3].imshow(np.clip(overlay, 0, 1))
axes[3].set_title("Overlay")
axes[3].axis("off")
plt.suptitle("Segmentasi berbasis tekstur", fontsize=11, y=1.05)
plt.tight_layout()
fig
7 Menggabungkan warna dan tekstur (gambaran)
Pada aplikasi nyata, keputusan sering memakai vektor fitur gabungan per piksel atau per objek:
\[ \mathbf{x} = \bigl[\, R,\, G,\, B,\, \text{Contrast},\, \text{Homogeneity},\,\ldots \,\bigr]^\top, \]
lalu K-means, klasifikasi (kNN, pohon), atau aturan (mis. “hijau” dan kontras rendah → daun). Modul ini memisahkan kedua jalur agar masing-masing dapat dipraktikkan; penggabungan menjadi topik ekstraksi ciri lanjutan.
flowchart LR
A[Citra RGB] --> B[Ruang warna]
B --> C[K-means / region growing]
C --> D[Label warna]
E[Citra grayscale] --> F[Kuantisasi L level]
F --> G[GLCM per jendela]
G --> H[Fitur Haralick]
H --> I[Ambang / K-means tekstur]
D --> J[Mask / analisis objek]
I --> J
8 Perbandingan dengan metode segmentasi lain
| Metode | Kriteria pemisahan | Kelebihan | Keterbatasan |
|---|---|---|---|
| Threshold intensitas (PCD 12) | \(f > T\) | cepat | abu-abu saja |
| Kesamaan warna | jarak RGB/HSV/Lab | objek berwarna | iluminasi, \(K\) atau \(\tau\) |
| GLCM / tekstur | pola pasangan intensitas | bedakan halus/kasar | biaya jendela; pilih \(d,\theta,L\) |
| Region growing warna | homogenitas lokal | wilayah terhubung | leaking |
| Watershed / superpixel | lanjutan | batas kompleks | di luar cakupan modul ini |
9 Implementasi referensi (Python)
import numpy as np
def glcm_normalized(g: np.ndarray, L: int = 8, dx: int = 1, dy: int = 0) -> np.ndarray:
"""Matriks ko-okurensi ternormalisasi; g sudah kuantisasi 0..L-1."""
if dx == 1 and dy == 0:
a, b = g[:, :-1].ravel(), g[:, 1:].ravel()
elif dx == 0 and dy == 1:
a, b = g[:-1, :].ravel(), g[1:, :].ravel()
else:
raise ValueError("offset tidak didukung pada contoh ini")
P = np.bincount(a * L + b, minlength=L * L).reshape(L, L).astype(np.float64)
return P / (P.sum() + 1e-12)
def haralick_contrast(P: np.ndarray) -> float:
L = P.shape[0]
ii, jj = np.meshgrid(np.arange(L), np.arange(L), indexing="ij")
return float(((ii - jj) ** 2 * P).sum())Pustaka scikit-image: graycomatrix, graycoprops — mendukung banyak \(\theta\), \(d\), dan fitur Haralick siap pakai.
10 Latihan mandiri
- Dua objek memiliki luminansi sama tetapi hue berbeda — jelaskan mengapa threshold PCD 12 gagal dan ruang warna mana yang lebih tepat.
- Pada K-means RGB dengan \(K=3\), apa yang terjadi bila bayangan menggelapkan satu wilayah tanpa mengubah hue secara ideal?
- Hitung manual entri \(P(i,j)\) untuk patch \(3\times3\) kuantisasi (\(L=4\)) dan \(d=1\) horizontal — bandingkan tekstur halus vs strip vertikal.
- Mengapa kontras GLCM naik pada tekstur bergelombang? Hubungkan dengan \((i-j)^2\) dalam rumus.
- Rancang pipeline singkat: citra buah di conveyor — kapan memakai segmentasi warna vs tekstur untuk memisahkan kulit cacat?
11 Referensi
- R. M. Haralick, K. Shanmugam & I. Dinstein, Textural Features for Image Classification, IEEE Trans. Syst. Man Cybern. (1973).
- R. C. Gonzalez & R. E. Woods, Digital Image Processing (segmentasi warna, tekstur, GLCM).
- scikit-image — graycomatrix
- scikit-image — graycoprops