Skip to main content

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:

Alur modul: ruang warna & metrik kesamaan → segmentasi warna (K-means, ambang jarak, region growing) → GLCM & fitur Haralick → segmentasi berbasis tekstur (jendela lokal).

Gambar 1: Ilustrasi dua jalur segmentasi: atas citra warna → segmentasi kesamaan warna (K-means, \(K=3\)); bawah citra grayscale → peta kontras GLCM lokal memisahkan area halus vs kasar.

0.1 Tujuan pembelajaran

  1. Menjelaskan batas threshold intensitas (PCD 12) dan kapan warna atau tekstur diperlukan.
  2. Membedakan ruang warna RGB, HSV, dan gambaran Lab; memilih metrik jarak warna yang sesuai.
  3. Menerapkan segmentasi kesamaan warna: K-means, ambang jarak, dan region growing berbasis warna.
  4. Mendefinisikan GLCM \(P(i,j \mid d,\theta)\), parameter \(d\) dan \(\theta\), serta normalisasi matriks.
  5. Menghitung fitur tekstur Haralick (kontras, homogenitas, energi, korelasi, entropi) dari GLCM.
  6. Menyusun segmentasi berbasis tekstur dengan jendela lokal dan ambang fitur GLCM.
  7. 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
Gambar 2: Satu citra, tiga tampilan: RGB; Hue (HSV, cyclic); Value. Dua piksel dengan \(V\) mirip dapat berbeda \(H\) — segmentasi warna memakai kanal yang relevan.

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)\):

  1. Inisialisasi antrian dengan seed; \(\mathcal{R} = \{(i_0,j_0)\}\).
  2. 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.
  3. 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
Gambar 3: Potongan citra 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
Gambar 4: Region growing pada citra HSV sintetis: seed di daun hijau; \(\tau_H = 0.08\) (jarak hue). Kanan: wilayah yang tumbuh dari seed.

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.

Gambar 5: Kiri: patch kuantisasi \(4\times4\) (\(L=4\)). Kanan: skema pasangan horizontal (\(d=1\), \(\theta=0°\)) — panah menghitung kontribusi ke \(P(i,j)\).

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
Gambar 6: Dua tekstur sintetis (halus vs kasar), GLCM normalisasi (\(L=8\), \(d=1\), \(\theta=0°\)), dan nilai kontras/homogenitas/energi.

6 Segmentasi berbasis tekstur (GLCM lokal)

Pola umum:

  1. Kuantisasi citra grayscale ke \(L\) level.
  2. Untuk setiap piksel (atau pusat jendela \(w \times w\)), hitung GLCM pada patch dan ekstrak fitur (mis. kontras).
  3. 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
Gambar 7: Citra sintetis: kiri halus, kanan bergelombang. Tengah: peta kontras GLCM (\(w=19\)). Kanan: mask tekstur kasar (ambang persentil 60).

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)

Daftar 1
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

  1. Dua objek memiliki luminansi sama tetapi hue berbeda — jelaskan mengapa threshold PCD 12 gagal dan ruang warna mana yang lebih tepat.
  2. Pada K-means RGB dengan \(K=3\), apa yang terjadi bila bayangan menggelapkan satu wilayah tanpa mengubah hue secara ideal?
  3. Hitung manual entri \(P(i,j)\) untuk patch \(3\times3\) kuantisasi (\(L=4\)) dan \(d=1\) horizontal — bandingkan tekstur halus vs strip vertikal.
  4. Mengapa kontras GLCM naik pada tekstur bergelombang? Hubungkan dengan \((i-j)^2\) dalam rumus.
  5. Rancang pipeline singkat: citra buah di conveyor — kapan memakai segmentasi warna vs tekstur untuk memisahkan kulit cacat?

11 Referensi