Modul teori — Ekstraksi ciri: bentuk, warna, & tekstur
Pengolahan Citra Digital (PCD), pertemuan ke-14
Modul ini menyatukan konsep ekstraksi ciri (feature extraction): mengubah citra atau objek tersegmentasi menjadi vektor angka yang dapat dipakai untuk klasifikasi, sortir, pencarian citra, atau kontrol kualitas. Tiga keluarga ciri utama — bentuk, warna, dan tekstur — sudah diperkenalkan secara terpisah pada fitur spasial (PCD 11), segmentasi warna & GLCM (PCD 13); di sini kita merangkainya dalam pipeline terpadu dari mask/objek ke vektor fitur dan keputusan.
Contoh penggunaan:
- Industri makanan: sortir kacang/biji — bentuk (kompakitas, aspect ratio), warna (hue kematangan), tekstur kulit (kontras GLCM).
- Inspeksi PCB: hitung area komponen, warna solder, tekstur permukaan logam vs plastik.
- Pertanian: klasifikasi buah matang vs mentah dari histogram warna HSV + fitur tekstur kulit.
- Biomedis: deskriptor bentuk sel (area, elongasi), warna staining, tekstur jaringan mikroskop.
- Pencarian citra (content-based image retrieval): vektor fitur global per citra untuk mencari gambar serupa.
Alur modul: definisi ekstraksi ciri & pipeline → ciri bentuk per objek → ciri warna per ROI → ciri tekstur per ROI → vektor gabungan & normalisasi → contoh klasifikasi → perbandingan dengan pendekatan modern.
0.1 Tujuan pembelajaran
- Mendefinisikan ekstraksi ciri dan perannya dalam pipeline visi komputer setelah segmentasi.
- Mengekstrak ciri bentuk per objek: area, perimeter, kompakitas, aspect ratio, dan ringkasan momen Hu.
- Mengekstrak ciri warna per ROI: mean/std kanal, histogram warna, dan statistik di ruang HSV.
- Mengekstrak ciri tekstur per ROI: fitur Haralick dari GLCM dan gambaran LBP.
- Menyusun vektor fitur gabungan, menerapkan normalisasi (min–max, z-score), dan memahami skala antar dimensi.
- Mengimplementasikan pipeline lengkap dengan NumPy/SciPy dan contoh klasifikasi kNN sederhana.
- Membandingkan ciri handcrafted dengan embedding deep learning (gambaran).
1 Apa itu ekstraksi ciri?
Ekstraksi ciri adalah proses mengubah data citra (piksel, region, atau objek) menjadi representasi numerik ringkas \(\mathbf{x} \in \mathbb{R}^d\) yang:
- Lebih mudah diproses oleh algoritma klasifikasi, regresi, atau clustering daripada raw pixel.
- Menangkap aspek relevan untuk tugas: ukuran, warna, pola permukaan, dll.
- Mengurangi dimensi dan redundansi — citra \(512\times512\) RGB punya \(786\,432\) nilai; vektor fitur \(d=15\) jauh lebih ringkas.
1.1 Dari segmentasi ke vektor fitur
Pipeline klasik (melanjutkan PCD 12 → PCD 11 / PCD 13):
flowchart TD A[Citra masuk] --> B[Segmentasi] B --> C["Mask / label objek"] C --> D[Morfologi opsional] D --> E[Labeling komponen] E --> F1[Ekstrak ciri bentuk] E --> F2[Ekstrak ciri warna] E --> F3[Ekstrak ciri tekstur] F1 --> G[Vektor fitur gabungan] F2 --> G F3 --> G G --> H[Normalisasi] H --> I["Klasifikasi / sortir / CBIR"]
| Tahap | Input | Output |
|---|---|---|
| Segmentasi | citra RGB/grayscale | mask biner atau label multi-kelas |
| Labeling | mask biner | array label \(L[i,j] \in \{0,1,\ldots,N\}\) |
| Ekstraksi | citra + mask/label per objek \(k\) | vektor \(\mathbf{x}_k\) |
| Keputusan | \(\mathbf{x}_k\) atau kumpulan \(\{\mathbf{x}_k\}\) | kelas, lolos/tidak, ranking |
Unit analisis: ciri dapat diekstrak per piksel (jendela lokal), per objek (seluruh komponen terhubung), atau per citra (global). Modul ini fokus pada per objek / ROI — paling umum setelah segmentasi.
1.2 Tiga keluarga ciri
| Keluarga | Apa yang diukur? | Prasyarat modul | Contoh skalar |
|---|---|---|---|
| Bentuk | geometri mask biner | PCD 11 | area, kompakitas, \(\Phi_1\) |
| Warna | distribusi warna di ROI | PCD 13 | \(\bar H, \bar S, \bar V\), histogram |
| Tekstur | pola intensitas spasial | PCD 13 | kontras, homogenitas GLCM |
Ketiganya saling melengkapi: dua objek dapat mirip bentuk tetapi berbeda warna; mirip warna tetapi berbeda tekstur; mirip tekstur tetapi berbeda bentuk. Vektor gabungan memungkinkan keputusan yang lebih robust.
1.2.1 Contoh kasus riil
| Situasi | Fitur yang membedakan | Contoh lapangan |
|---|---|---|
| Bentuk sama, warna beda | warna (Hue, Saturation) | Jeruk vs apel di conveyor: area dan kompakitas hampir sama (keduanya bulat), tetapi mean Hue jeruk oranye (~30–40°) vs apel merah/hijau (~0–15°). Ciri bentuk saja gagal; warna yang memisahkan kelas. |
| Warna sama, tekstur beda | tekstur (GLCM) | Jeruk utuh vs berjamur/berkerut: mean Hue dan Saturation masih oranye, tetapi kontras GLCM naik dan homogenitas turun pada area cacat. Tekstur mendeteksi cacat; warna saja tidak cukup. |
| Tekstur sama, bentuk beda | bentuk (aspect ratio, kompakitas) | Kacang tanah vs biji bundar (PCD 11): permukaan keduanya kasar (kontras GLCM mirip), tetapi kacang memanjang (aspect ratio tinggi, kompakitas lebih rendah) vs biji bundar. Bentuk yang memisahkan. |
| Semua perlu dicek | vektor gabungan | Sortir kacang cacat: objek bulat hijau kecil bisa mirip kacang utuh di bentuk, mirip hijau normal di warna, tetapi tekstur kasar abnormal. Aturan lolos hanya jika kompakitas normal dan Hue dalam rentang dan kontras di bawah ambang cacat — satu fitur saja berisiko salah klasifikasi. |
PCD/assets/pcd14_contoh_kasus/ATTRIBUTIONS.md.
Contoh tambahan singkat (baris bawah figur): koin (bentuk lingkaran sama, warna berbeda); beton vs cat abu-abu (warna mirip, tekstur kasar vs halus); goresan/retak logam (tepi mirip di tekstur, bentuk retak lebih panjang dan tidak teratur).
2 Ciri bentuk (shape features)
Ciri bentuk dihitung dari mask biner \(M_k\) objek ke-\(k\) (atau kontur objek). Detail teori momen ada di PCD 11; berikut ringkasan operasional untuk ekstraksi.
2.1 Deskriptor geometri dasar
| Nama | Rumus / definisi | Interpretasi |
|---|---|---|
| Area \(A\) | \(A = \sum M[i,j]\) | ukuran objek (piksel²) |
| Perimeter \(P\) | panjang kontur; aproksimasi: jumlah piksel batas | keliling |
| Kompakitas \(C\) | \(C = 4\pi A / P^2\) | 1 = lingkaran ideal; \(<1\) jika tidak bulat |
| Aspect ratio | \(w_{\mathrm{bbox}} / h_{\mathrm{bbox}}\) | memanjang vs bundar |
| Extent | \(A / (w_{\mathrm{bbox}} \cdot h_{\mathrm{bbox}})\) | kepadatan dalam kotak |
| Centroid \((\bar x, \bar y)\) | pusat massa mask | lokasi (sering bukan fitur klasifikasi bentuk) |
2.1.1 Contoh penggunaan per deskriptor
| Deskriptor | Pertanyaan operasional | Kasus riil |
|---|---|---|
| Area \(A\) | “Seberapa besar?” / “Berapa objek?” | Butir beras di conveyor — hitung jumlah butir dan tolak serpihan di bawah ambang area (PCD 11). Sel darah mikroskop — sel abnormal sering lebih besar/kecil dari rentang area normal. Komponen SMD — area solder paste di luar toleransi → cacat. |
| Perimeter \(P\) | “Seberapa panjang batas?” | Retak logam — perimeter kontur retak panjang relatif terhadap area → indikator keparahan. Objek bergerigi — perimeter besar dibanding area setara → kompakitas turun. |
| Kompakitas \(C\) | “Bulat atau tidak?” | Sortir kacang/tablet — kacang utuh bundar (\(C\) tinggi) vs pecahan/penyok (\(C\) rendah). Sel histologi — sel normal mendekati bulat; sel abnormal memanjang atau berduri. |
| Aspect ratio | “Memanjang atau bundar?” | Kacang tanah vs biji bundar — kacang memanjang (aspect ratio \(\gg 1\)), biji bundar (\(\approx 1\)). Goresan vs noda bulat pada logam — goresan memanjang, noda bundar. |
| Extent | “Seberapa padat mengisi kotak?” | Pecahan/serpihan — area kecil tetapi bbox besar → extent rendah (objek “tipis” atau berlubang). Tablet utuh — extent tinggi karena massa foreground memenuhi kotak. |
| Centroid | “Di mana pusatnya?” | Robot pick-and-place PCB — gripper menuju centroid komponen. Drone semprot — koordinat centroid bercak gulma. Pelacakan bola per frame video — centroid sebagai posisi objek (PCD 11). |
Cara membaca kompakitas: lingkaran sempurna \(C=1\); bintang, salib, atau objek bergerigi → \(C\) menurun. Sortir “bulat vs pipih” sering memakai \(C\) dan aspect ratio bersama-sama — kompakitas saja tidak membedakan lingkaran vs elips bundar; aspect ratio melengkapi.
2.2 Momen Hu (ringkasan)
Momen pusat ternormalisasi \(\eta_{pq}\) dan kombinasi Hu \(\Phi_1, \ldots, \Phi_7\) dirancang invarian terhadap translasi, rotasi, dan skala uniform (ideal). Tiga pertama paling sering dipakai:
\[ \Phi_1 = \eta_{20} + \eta_{02}, \quad \Phi_2 = (\eta_{20}-\eta_{02})^2 + 4\eta_{11}^2. \]
Lihat PCD 11 untuk rumus lengkap dan contoh numerik. Dalam vektor fitur, \(\Phi_1, \Phi_2\) sering melengkapi area dan kompakitas.
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
from scipy import ndimage
def make_star(h, w, cy, cx, r_out, r_in, n=5):
from matplotlib.path import Path
angles = np.linspace(0, 2 * np.pi, 2 * n + 1)[:-1]
pts = []
for i, a in enumerate(angles):
r = r_out if i % 2 == 0 else r_in
pts.append((cx + r * np.cos(a - np.pi / 2), cy + r * np.sin(a - np.pi / 2)))
Y, X = np.mgrid[:h, :w]
poly = Path(pts)
return poly.contains_points(np.column_stack([X.ravel(), Y.ravel()])).reshape(h, w)
def shape_features(mask):
A = mask.sum()
if A == 0:
return None
er = ndimage.binary_erosion(mask)
P = (mask ^ er).sum()
C = 4 * np.pi * A / (P**2 + 1e-9)
ys, xs = np.where(mask)
h_bb = ys.max() - ys.min() + 1
w_bb = xs.max() - xs.min() + 1
ar = w_bb / (h_bb + 1e-9)
cy, cx = ys.mean(), xs.mean()
mu20 = ((ys - cy) ** 2).sum()
mu02 = ((xs - cx) ** 2).sum()
mu11 = ((ys - cy) * (xs - cx)).sum()
eta20, eta02, eta11 = mu20 / A**2, mu02 / A**2, mu11 / A**2
phi1 = eta20 + eta02
return dict(A=A, P=P, C=C, ar=ar, phi1=phi1)
h, w = 120, 120
Y, X = np.mgrid[:h, :w]
shapes = [
("Lingkaran", (X - 60) ** 2 + (Y - 60) ** 2 <= 40**2),
("Elips", ((X - 60) / 50) ** 2 + ((Y - 60) / 25) ** 2 <= 1),
("Bintang", make_star(h, w, 60, 60, 45, 18)),
]
fig, axes = plt.subplots(1, 3, figsize=(10, 3.5))
rows_txt = []
for ax, (name, m) in zip(axes, shapes):
ax.imshow(m, cmap="Greys_r", vmin=0, vmax=1)
ax.set_title(name)
ax.axis("off")
f = shape_features(m)
rows_txt.append((name, f))
txt = "Bentuk A C AR phi1\n" + "-" * 42 + "\n"
for name, f in rows_txt:
txt += f"{name:10s} {f['A']:5.0f} {f['C']:.3f} {f['ar']:.2f} {f['phi1']:.4f}\n"
fig.text(0.5, -0.02, txt, ha="center", fontsize=9, family="monospace")
plt.suptitle("Ciri bentuk membedakan geometri objek", fontsize=11, y=1.05)
plt.tight_layout()
fig
3 Ciri warna (color features)
Ciri warna merangkum distribusi warna di dalam ROI objek \(k\) — biasanya dari citra RGB asli (bukan hanya mask). Ruang warna dibahas di PCD 13.
3.1 Statistik kanal (first-order)
Untuk ROI dengan mask \(M_k\), hitung per kanal \(c \in \{R,G,B\}\) (atau \(H,S,V\)):
\[ \bar{c} = \frac{1}{A_k}\sum_{(i,j): M_k} c[i,j], \qquad \sigma_c = \sqrt{\frac{1}{A_k}\sum_{(i,j): M_k} \bigl(c[i,j]-\bar{c}\bigr)^2}. \]
Mean \(\bar{c}\) → warna dominan rata-rata; std \(\sigma_c\) → variasi warna dalam objek (homogen vs bergradasi).
3.2 Histogram warna
Histogram \(h_c(b)\) = frekuensi piksel kanal \(c\) pada bin \(b\) (mis. 8–32 bin per kanal). Vektor fitur = concatenation \([h_R; h_G; h_B]\) → dimensi \(3B\).
| Metode | Dimensi tipikal | Kelebihan | Keterbatasan |
|---|---|---|---|
| Mean/std per kanal | 6 (RGB) atau 6 (HSV) | ringkas, cepat | kehilangan distribusi multimodal |
| Histogram \(B\) bin/kanal | \(3B\) | menangkap multimodal | sensitif iluminasi jika RGB |
| Histogram 2D (H–S) | \(B_H \times B_S\) | warna semantik | perlu ruang HSV/Lab |
Praktik: untuk sortir kematangan buah, mean Hue dan Saturation di HSV sering cukup; histogram H berguna bila ada campuran warna (mis. belang).
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(3)
h, w = 100, 100
def rgb_to_hsv(rgb):
rgb = np.clip(rgb, 0, 1)
r, g, b = rgb[..., 0], rgb[..., 1], rgb[..., 2]
mx, mn = rgb.max(axis=-1), rgb.min(axis=-1)
v = mx
d = mx - mn
s = np.where(mx > 1e-9, d / mx, 0.0)
h_out = np.zeros_like(v)
mask = d > 1e-9
rm, gm, bm = r[mask], g[mask], b[mask]
dm = d[mask]
h_out[mask] = np.where(rm == mx[mask], ((gm - bm) / dm) % 6,
np.where(gm == mx[mask], (bm - rm) / dm + 2, (rm - gm) / dm + 4))
h_out = (h_out / 6) % 1.0
return np.stack([h_out, s, v], axis=-1)
def color_stats(rgb, mask):
hsv = rgb_to_hsv(rgb)
pix = hsv[mask]
mean_hsv = pix.mean(axis=0)
std_hsv = pix.std(axis=0)
hist_h, _ = np.histogram(pix[:, 0], bins=16, range=(0, 1))
hist_h = hist_h / (hist_h.sum() + 1e-9)
return mean_hsv, std_hsv, hist_h
rois = []
for hue_center, name in [(0.33, "Hijau"), (0.08, "Oranye")]:
rgb = np.zeros((h, w, 3))
hsv = np.zeros((h, w, 3))
hsv[..., 0] = hue_center + rng.normal(0, 0.02, (h, w))
hsv[..., 1] = 0.75 + rng.normal(0, 0.05, (h, w))
hsv[..., 2] = 0.72 + rng.normal(0, 0.04, (h, w))
hsv = np.clip(hsv, 0, 1)
# HSV → RGB sederhana
hi = (hsv[..., 0] * 6).astype(int) % 6
f = hsv[..., 0] * 6 - hi
p = hsv[..., 2] * (1 - hsv[..., 1])
q = hsv[..., 2] * (1 - f * hsv[..., 1])
t = hsv[..., 2] * (1 - (1 - f) * hsv[..., 1])
rgb = np.zeros_like(hsv)
for i in range(6):
m = hi == i
if i == 0:
rgb[m] = np.stack([hsv[..., 2], t, p], axis=-1)[m]
elif i == 1:
rgb[m] = np.stack([q, hsv[..., 2], p], axis=-1)[m]
elif i == 2:
rgb[m] = np.stack([p, hsv[..., 2], t], axis=-1)[m]
elif i == 3:
rgb[m] = np.stack([p, q, hsv[..., 2]], axis=-1)[m]
elif i == 4:
rgb[m] = np.stack([t, p, hsv[..., 2]], axis=-1)[m]
else:
rgb[m] = np.stack([hsv[..., 2], p, q], axis=-1)[m]
mask = np.ones((h, w), dtype=bool)
rois.append((name, rgb, mask))
fig, axes = plt.subplots(2, 3, figsize=(10, 5.5))
for col, (name, rgb, mask) in enumerate(rois):
mean_hsv, std_hsv, hist_h = color_stats(rgb, mask)
axes[0, col].imshow(np.clip(rgb, 0, 1))
axes[0, col].set_title(name)
axes[0, col].axis("off")
axes[1, col].bar(np.arange(16), hist_h, color="#e67e22" if col else "#27ae60", alpha=0.85)
axes[1, col].set_xlabel("Bin Hue")
axes[1, col].set_title(rf"$\bar H={mean_hsv[0]:.2f}$, $\bar S={mean_hsv[1]:.2f}$, $\bar V={mean_hsv[2]:.2f}$")
axes[1, 2].axis("off")
axes[1, 2].text(
0.1, 0.5,
"Mean H membedakan\nhijau (~0.33) vs\noranye (~0.08).\nV dapat mirip.",
fontsize=10, va="center",
)
plt.suptitle("Ciri warna: statistik HSV & histogram Hue", fontsize=11, y=1.02)
plt.tight_layout()
fig
4 Ciri tekstur (texture features)
Ciri tekstur mengukur pola intensitas spasial — halus vs kasar, teratur vs acak. Fondasi GLCM dan fitur Haralick ada di PCD 13.
4.1 GLCM & Haralick (ringkasan operasional)
Untuk patch grayscale \(g\) di dalam ROI (atau seluruh ROI jika kecil):
- Kuantisasi ke \(L\) level (8–16).
- Bentuk GLCM \(p(i,j)\) untuk pasangan \((d, \theta)\).
- Ekstrak skalar: kontras, homogenitas, energi, entropi, korelasi.
\[ \text{Contrast} = \sum_{i,j}(i-j)^2 p(i,j), \qquad \text{Homogeneity} = \sum_{i,j}\frac{p(i,j)}{1+|i-j|}. \]
Per objek: hitung GLCM pada bounding box objek (hanya piksel dalam mask), atau rata-rata fitur dari jendela-jendela kecil di dalam ROI.
4.2 LBP — gambaran singkat
Local Binary Pattern (LBP): bandingkan intensitas pusat dengan \(P\) tetangga pada radius \(R\); hasilkan pola biner → histogram LBP. Invarian terhadap monotonic illumination change (versi uniform). Cocok untuk tekstur mikro (permukaan logam, kain, kulit).
| Metode | Input | Output tipikal |
|---|---|---|
| GLCM Haralick | grayscale ROI | 4–5 skalar per \((d,\theta)\) |
| LBP | grayscale ROI | histogram 59 bin (uniform) |
| Gabor filter bank | grayscale | energi per orientasi/frekuensi |
Modul ini fokus GLCM karena sudah diimplementasikan di PCD 13; LBP disebut sebagai alternatif modern yang ringan.
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(9)
L = 8
h, w = 80, 80
smooth = np.clip(120 + rng.normal(0, 5, (h, w)), 0, 255)
xx = np.tile(np.arange(w), (h, 1))
rough = np.clip(120 + 35 * np.sin(0.6 * xx) + rng.normal(0, 4, (h, w)), 0, 255)
def quantize(img, L=8):
return np.clip((img / 256 * L).astype(np.int32), 0, L - 1)
def glcm_features(img, L=8):
g = quantize(img, L)
a, b = g[:, :-1].ravel(), g[:, 1:].ravel()
P = np.bincount(a * L + b, minlength=L * L).reshape(L, L).astype(np.float64)
P /= P.sum() + 1e-12
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()
return contrast, homogeneity, energy
fig, axes = plt.subplots(1, 3, figsize=(10, 3.2))
for col, (img, name) in enumerate([(smooth, "Halus"), (rough, "Kasar")]):
c, hom, en = glcm_features(img)
axes[col].imshow(img, cmap="gray", vmin=0, vmax=255)
axes[col].set_title(rf"{name}: mean={img.mean():.0f}")
axes[col].axis("off")
axes[col].text(0.02, 0.02, f"C={c:.2f}\nH={hom:.3f}\nE={en:.3f}", transform=axes[col].transAxes,
fontsize=9, va="bottom", color="yellow", family="monospace",
bbox=dict(facecolor="black", alpha=0.5))
axes[2].axis("off")
axes[2].text(0.1, 0.55, "Mean intensitas\n≈ sama (≈120)\n\nKontras GLCM:\nhalus < kasar\n\nHomogenitas:\nhalus > kasar", fontsize=10, va="center")
plt.suptitle("Ciri tekstur melengkapi ciri intensitas first-order", fontsize=11, y=1.05)
plt.tight_layout()
fig
5 Vektor fitur gabungan
5.1 Concatenation
Untuk objek \(k\), gabungkan ciri dari ketiga keluarga:
\[ \mathbf{x}_k = \bigl[\, \underbrace{A, C, \Phi_1}_{\text{bentuk}},\; \underbrace{\bar H, \bar S, \bar V}_{\text{warna}},\; \underbrace{\text{Contrast}, \text{Homog.}, \text{Energy}}_{\text{tekstur}} \,\bigr]^\top \in \mathbb{R}^d. \]
Dimensi \(d\) tergantung pilihan deskriptor — dapat 10–100+. Nama fitur dan urutan harus konsisten di seluruh dataset.
5.2 Normalisasi
Skala antar fitur sangat berbeda (area \(\sim 10^3\), \(\Phi_1 \sim 10^{-3}\), kontras \(\sim 1\)). Tanpa normalisasi, algoritma berbasis jarak (kNN, SVM) akan didominasi fitur bernilai besar.
| Metode | Rumus | Kapan dipakai |
|---|---|---|
| Min–max | \(x' = (x - x_{\min})/(x_{\max}-x_{\min})\) | rentang fitur terbatas, \([0,1]\) |
| Z-score | \(x' = (x - \mu)/\sigma\) | distribusi mendekati normal |
| L2 norm | \(\mathbf{x}' = \mathbf{x}/\|\mathbf{x}\|_2\) | panjang vektor seragam |
Normalisasi dihitung dari statistik seluruh training set (bukan per objek tunggal), lalu diterapkan sama pada data uji.
5.3 Contoh pipeline: klasifikasi tiga kelas
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
from scipy import ndimage
def rgb_to_hsv(rgb):
rgb = np.clip(rgb, 1e-9, 1)
r, g, b = rgb[..., 0], rgb[..., 1], rgb[..., 2]
mx, mn = rgb.max(axis=-1), rgb.min(axis=-1)
v = mx
d = mx - mn
s = np.where(mx > 1e-9, d / mx, 0.0)
h_out = np.zeros_like(v)
mask = d > 1e-9
rm, gm, bm = r[mask], g[mask], b[mask]
dm = d[mask]
h_out[mask] = np.where(rm == mx[mask], ((gm - bm) / dm) % 6,
np.where(gm == mx[mask], (bm - rm) / dm + 2, (rm - gm) / dm + 4))
return np.stack([(h_out / 6) % 1.0, s, v], axis=-1)
def extract_features(rgb, mask, gray):
A = mask.sum()
er = ndimage.binary_erosion(mask)
P = (mask ^ er).sum()
C = 4 * np.pi * A / (P**2 + 1e-9)
ys, xs = np.where(mask)
cy, cx = ys.mean(), xs.mean()
mu20 = ((ys - cy) ** 2).sum() / A**2
mu02 = ((xs - cx) ** 2).sum() / A**2
phi1 = mu20 + mu02
hsv = rgb_to_hsv(rgb)
pix_hsv = hsv[mask]
mean_hsv = pix_hsv.mean(axis=0)
g_roi = gray[mask]
g_patch = g_roi.reshape(-1, 1) if g_roi.size > 1 else g_roi
# GLCM on cropped bbox
rows, cols = np.where(mask)
r0, r1 = rows.min(), rows.max() + 1
c0, c1 = cols.min(), cols.max() + 1
patch = gray[r0:r1, c0:c1]
L = 8
q = np.clip((patch / 256 * L).astype(int), 0, L - 1)
a, b = q[:, :-1].ravel(), q[:, 1:].ravel()
P = np.bincount(a * L + b, minlength=L * L).reshape(L, L).astype(float)
P /= P.sum() + 1e-12
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()
return np.array([A, C, phi1, *mean_hsv, contrast, homogeneity])
def make_sample(rng, cls):
h, w = 80, 80
Y, X = np.ogrid[:h, :w]
rgb = np.zeros((h, w, 3))
if cls == 0: # bulat hijau halus
mask = (X - 40) ** 2 + (Y - 40) ** 2 <= 30**2
rgb[mask] = [0.2, 0.7, 0.35]
gray = np.where(mask, 130, 30)
elif cls == 1: # elips oranye
mask = ((X - 40) / 35) ** 2 + ((Y - 40) / 18) ** 2 <= 1
rgb[mask] = [0.9, 0.5, 0.15]
gray = np.where(mask, 145, 30)
else: # kotak biru kasar
mask = (X >= 20) & (X <= 60) & (Y >= 20) & (Y <= 60)
rgb[mask] = [0.2, 0.45, 0.85]
xx = np.tile(np.arange(w), (h, 1))
gray = np.where(mask, 120 + 25 * np.sin(0.5 * xx), 30)
rgb = np.clip(rgb + rng.normal(0, 0.03, rgb.shape), 0, 1)
gray = np.clip(gray.astype(float) + rng.normal(0, 3, (h, w)), 0, 255)
return rgb, mask, gray
rng = np.random.default_rng(14)
n_per = 25
X_list, y_list = [], []
for cls in range(3):
for _ in range(n_per):
rgb, mask, gray = make_sample(rng, cls)
X_list.append(extract_features(rgb, mask, gray))
y_list.append(cls)
X = np.array(X_list)
y = np.array(y_list)
# train/test split
idx = rng.permutation(len(y))
n_train = int(0.7 * len(y))
tr, te = idx[:n_train], idx[n_train:]
X_tr, X_te = X[tr], X[te]
y_tr, y_te = y[tr], y[te]
mu, sig = X_tr.mean(axis=0), X_tr.std(axis=0) + 1e-9
X_tr_n = (X_tr - mu) / sig
X_te_n = (X_te - mu) / sig
def knn_predict(X_tr, y_tr, X_te, k=3):
preds = []
for x in X_te:
d = np.linalg.norm(X_tr - x, axis=1)
nn = np.argsort(d)[:k]
vals, cnts = np.unique(y_tr[nn], return_counts=True)
preds.append(vals[cnts.argmax()])
return np.array(preds)
acc = (knn_predict(X_tr_n, y_tr, X_te_n) == y_te).mean()
labels_cls = ["Bulat hijau", "Elips oranye", "Kotak kasar"]
fig, axes = plt.subplots(1, 2, figsize=(10, 4))
# tampilkan satu sampel per kelas
for cls in range(3):
i = np.where(y == cls)[0][0]
rgb, mask, gray = make_sample(rng, cls)
axes[0].imshow(np.clip(rgb, 0, 1)) if cls == 0 else None
for cls in range(3):
rgb, mask, gray = make_sample(np.random.default_rng(cls), cls)
axes[0].text(10 + cls * 26, 72, labels_cls[cls][0], color="white", fontsize=8,
bbox=dict(facecolor="black", alpha=0.5))
# scatter 2D: C vs contrast (fitur bentuk vs tekstur)
colors = ["#27ae60", "#e67e22", "#3498db"]
for cls in range(3):
m = y_tr == cls
axes[1].scatter(X_tr_n[m, 1], X_tr_n[m, 5], c=colors[cls], label=labels_cls[cls], alpha=0.7, s=40)
axes[0].set_title("Tiga kelas objek sintetis")
axes[0].axis("off")
axes[1].set_xlabel("Kompakitas (z-score)")
axes[1].set_ylabel("Kontras GLCM (z-score)")
axes[1].legend(fontsize=8)
axes[1].set_title(rf"kNN ($k=3$): akurasi uji = {acc:.0%}")
plt.suptitle("Pipeline ekstraksi ciri → normalisasi → klasifikasi", fontsize=11, y=1.02)
plt.tight_layout()
fig
6 Pemilihan dan reduksi ciri (gambaran)
Tidak semua fitur selalu relevan. Korelasi tinggi antar fitur (mis. area dan perimeter) menambah redundansi. Teknik ringkas:
- Filter: pilih fitur dengan korelasi tinggi ke label (ANOVA, mutual information).
- Wrapper / embedded: seleksi saat training (LASSO, feature importance pohon).
- PCA: proyeksi ke subruang ortogonal — kehilangan interpretabilitas.
Untuk proyek kuliah, mulai dengan vektor kecil (5–15 fitur) yang interpretable; tambah kompleksitas bila baseline jelas.
7 Handcrafted vs deep learning
| Aspek | Ciri handcrafted (modul ini) | CNN / deep learning |
|---|---|---|
| Interpretabilitas | tinggi (area, hue, kontras) | rendah (embedding) |
| Data | efektif dengan sedikit sampel | butuh banyak data |
| Desain | perlu domain knowledge | end-to-end dari piksel |
| Kecepatan inferensi | sangat cepat | GPU membantu |
| Pipeline | segmentasi → fitur → klasifikator | sering langsung dari citra |
Praktik industri: ciri handcrafted masih dipakai bila aturan jelas (sortir ukuran), data terbatas, atau explainability wajib. CNN unggul pada variasi bentuk/warna/tekstur kompleks. Hybrid — CNN embedding + fitur geometri — juga umum.
8 Alur pipeline lengkap (PCD 09–14)
flowchart LR
subgraph seg ["Segmentasi PCD 12-13"]
S1["Threshold / warna / tekstur"]
end
subgraph morph ["Pembersihan PCD 09"]
M1["Opening / closing"]
end
subgraph feat ["Ekstraksi PCD 14"]
F1[Bentuk]
F2[Warna]
F3[Tekstur]
end
subgraph ml [Keputusan]
K1["Normalisasi + kNN / SVM / aturan"]
end
S1 --> M1 --> F1
M1 --> F2
M1 --> F3
F1 --> K1
F2 --> K1
F3 --> K1
9 Implementasi referensi (Python)
import numpy as np
from scipy import ndimage
def shape_descriptors(mask: np.ndarray) -> dict:
"""Deskriptor bentuk dasar dari mask biner."""
A = float(mask.sum())
er = ndimage.binary_erosion(mask)
P = float((mask ^ er).sum())
ys, xs = np.where(mask)
h_bb = ys.max() - ys.min() + 1
w_bb = xs.max() - xs.min() + 1
return {
"area": A,
"perimeter": P,
"compactness": 4 * np.pi * A / (P**2 + 1e-9),
"aspect_ratio": w_bb / (h_bb + 1e-9),
"extent": A / (h_bb * w_bb + 1e-9),
}
def color_descriptors_hsv(hsv: np.ndarray, mask: np.ndarray) -> dict:
"""Mean & std HSV dalam ROI."""
pix = hsv[mask]
return {
"mean_h": float(pix[:, 0].mean()),
"mean_s": float(pix[:, 1].mean()),
"mean_v": float(pix[:, 2].mean()),
"std_h": float(pix[:, 0].std()),
"std_s": float(pix[:, 1].std()),
"std_v": float(pix[:, 2].std()),
}
def build_feature_vector(shape: dict, color: dict, texture: dict) -> np.ndarray:
"""Gabungkan dict fitur menjadi vektor 1D (urutan tetap)."""
keys = [
"area", "compactness", "aspect_ratio",
"mean_h", "mean_s", "mean_v",
"contrast", "homogeneity", "energy",
]
merged = {**shape, **color, **texture}
return np.array([merged[k] for k in keys], dtype=np.float64)Pustaka tambahan: skimage.measure.regionprops (area, perimeter, moments), skimage.feature.graycomatrix / graycoprops, skimage.feature.local_binary_pattern.
10 Latihan mandiri
- Rancang vektor fitur untuk sortir kacang di conveyor: fitur bentuk, warna, dan tekstur apa yang paling relevan? Berapa dimensi \(d\)?
- Mengapa mean RGB saja sering gagal membedakan buah matang vs mentah di bawah bayangan? Fitur warna apa yang lebih robust?
- Dua objek memiliki area sama tetapi kontras GLCM berbeda — apakah ciri bentuk saja cukup untuk klasifikasi? Jelaskan.
- Hitung z-score manual untuk dua fitur: area \(= 1200\) dan \(\Phi_1 = 0.002\) jika \(\mu_A=1000\), \(\sigma_A=200\), \(\mu_{\Phi_1}=0.0015\), \(\sigma_{\Phi_1}=0.0005\).
- Bandingkan histogram Hue 32 bin vs mean Hue untuk objek berwarna campuran (mis. belang). Mana lebih informatif?
- Jelaskan mengapa normalisasi fitur wajib sebelum kNN tetapi kurang kritis untuk pohon keputusan berbasis ambang.
11 Referensi
- M. Hu, Visual Pattern Recognition by Moment Invariants, IRE Trans. Info. Theory (1962) — momen Hu.
- R. M. Haralick et al., Textural Features for Image Classification (1973) — GLCM.
- T. Ojala, M. Pietikäinen & D. Harwood, A Comparative Study of Texture Measures with Classification Based on Feature Distributions, Pattern Recognition (1996) — LBP.
- R. C. Gonzalez & R. E. Woods, Digital Image Processing — bab deskriptor bentuk, warna, tekstur.
- scikit-image — regionprops
- scikit-image — graycomatrix / graycoprops