Menguasai Segmentasi Imej: Cara Teknik Tradisional Masih Bersinar di Era Digital

pengenalan

Pembahagian imej, salah satu prosedur paling asas dalam penglihatan komputer, membolehkan sistem mengurai dan menganalisis pelbagai kawasan dalam imej. Sama ada anda berurusan dengan pengecaman objek, pengimejan perubatan atau pemanduan autonomi, segmentasi ialah perkara yang memecahkan imej kepada bahagian yang bermakna.

Walaupun model pembelajaran mendalam terus menjadi semakin popular dalam tugasan ini, teknik tradisional dalam pemprosesan imej digital masih berkuasa dan praktikal. Pendekatan yang disemak dalam siaran ini termasuk ambang, pengesanan tepi, berasaskan wilayah dan pengelompokan dengan melaksanakan set data yang diiktiraf dengan baik untuk analisis imej sel, MIVIA HEp-2 Image Dataset.

Set Data Imej MIVIA HEp-2

Set Data Imej MIVIA HEp-2 ialah satu set gambar sel yang digunakan untuk menganalisis corak antibodi antinuklear (ANA) melalui sel HEp-2. Ia terdiri daripada gambar 2D yang diambil melalui mikroskop pendarfluor. Ini menjadikannya sangat sesuai untuk tugasan pembahagian, yang paling penting adalah yang berkaitan dengan analisis imej perubatan, di mana pengesanan kawasan selular adalah paling penting.

Sekarang, mari kita beralih kepada teknik pembahagian yang digunakan untuk memproses imej ini, membandingkan prestasinya berdasarkan skor F1.

1. Segmentasi Ambang

Ambang ialah proses di mana imej skala kelabu ditukar kepada imej binari berdasarkan keamatan piksel. Dalam set data MIVIA HEp-2, proses ini berguna dalam pengekstrakan sel dari latar belakang. Ia mudah dan berkesan pada tahap yang agak besar, terutamanya dengan kaedah Otsu, kerana ia mengira sendiri ambang optimum.

Kaedah Otsu ialah kaedah ambang automatik, di mana ia cuba mencari nilai ambang terbaik untuk menghasilkan varians dalam kelas yang minimum, dengan itu memisahkan dua kelas: latar depan (sel) dan latar belakang. Kaedah ini mengkaji histogram imej dan mengira ambang sempurna, di mana jumlah varians keamatan piksel dalam setiap kelas diminimumkan.

# Thresholding Segmentation
def thresholding(img):
    # Convert image to grayscale
    gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

    # Apply Otsu's thresholding
    _, thresh = cv.threshold(gray, 0, 255, cv.THRESH_BINARY + cv.THRESH_OTSU)

    return thresh

2. Segmentasi Pengesanan Tepi

Pengesanan tepi berkaitan dengan mengenal pasti sempadan objek atau kawasan, seperti tepi sel dalam set data MIVIA HEp-2. Daripada banyak kaedah yang tersedia untuk mengesan perubahan intensiti mendadak, Pengesan Tepi Canny ialah kaedah terbaik dan oleh itu paling sesuai digunakan untuk mengesan sempadan selular.

Pengesan Tepi Canny ialah algoritma berbilang peringkat yang boleh mengesan tepi dengan mengesan kawasan kecerunan intensiti yang kuat. Proses ini merangkumi pelicinan dengan penapis Gaussian, pengiraan kecerunan keamatan, penggunaan penindasan bukan maksimum untuk menghapuskan tindak balas palsu dan operasi ambang dua kali terakhir untuk pengekalan hanya tepi yang menonjol.

# Edge Detection Segmentation
def edge_detection(img):
    # Convert image to grayscale
    gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

    # Apply Gaussian blur
    gray = cv.GaussianBlur(gray, (3, 3), 0)

    # Calculate lower and upper thresholds for Canny edge detection
    sigma = 0.33
    v = np.median(gray)
    lower = int(max(0, (1.0 - sigma) * v))
    upper = int(min(255, (1.0 + sigma) * v))

    # Apply Canny edge detection
    edges = cv.Canny(gray, lower, upper)

    # Dilate the edges to fill gaps
    kernel = np.ones((5, 5), np.uint8)
    dilated_edges = cv.dilate(edges, kernel, iterations=2)

    # Clean the edges using morphological opening
    cleaned_edges = cv.morphologyEx(dilated_edges, cv.MORPH_OPEN, kernel, iterations=1)

    # Find connected components and filter out small components
    num_labels, labels, stats, _ = cv.connectedComponentsWithStats(
        cleaned_edges, connectivity=8
    )
    min_size = 500
    filtered_mask = np.zeros_like(cleaned_edges)
    for i in range(1, num_labels):
        if stats[i, cv.CC_STAT_AREA] >= min_size:
            filtered_mask[labels == i] = 255

    # Find contours of the filtered mask
    contours, _ = cv.findContours(
        filtered_mask, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE
    )

    # Create a filled mask using the contours
    filled_mask = np.zeros_like(gray)
    cv.drawContours(filled_mask, contours, -1, (255), thickness=cv.FILLED)

    # Perform morphological closing to fill holes
    final_filled_image = cv.morphologyEx(
        filled_mask, cv.MORPH_CLOSE, kernel, iterations=2
    )

    # Dilate the final filled image to smooth the edges
    final_filled_image = cv.dilate(final_filled_image, kernel, iterations=1)

    return final_filled_image

3. Segmentasi Berasaskan Wilayah

Pengsegmenan berasaskan wilayah mengumpulkan piksel yang serupa bersama-sama ke dalam kawasan, bergantung pada kriteria tertentu seperti keamatan atau warna. Teknik Pembahagian kawasan tadahan air boleh digunakan untuk membantu dalam membahagikan imej sel HEp-2 agar dapat mengesan kawasan tersebut yang mewakili sel; ia menganggap keamatan piksel sebagai permukaan topografi dan menggariskan kawasan yang membezakan.

Segmen kawasan tadahan air merawat keamatan piksel sebagai permukaan topografi. Algoritma mengenal pasti "lembangan" di mana ia mengenal pasti minima tempatan dan kemudian membanjiri lembangan ini secara beransur-ansur untuk membesarkan kawasan yang berbeza. Teknik ini agak berguna apabila seseorang ingin mengasingkan objek yang menyentuh, seperti dalam kes sel dalam imej mikroskopik, tetapi ia boleh menjadi sensitif kepada bunyi. Proses ini boleh dipandu oleh penanda dan pembahagian berlebihan selalunya boleh dikurangkan.

# Region-Based Segmentation
def region_based(img):
    # Convert image to grayscale
    gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

    # Apply Otsu's thresholding
    _, thresh = cv.threshold(gray, 0, 255, cv.THRESH_BINARY_INV + cv.THRESH_OTSU)

    # Apply morphological opening to remove noise
    kernel = np.ones((3, 3), np.uint8)
    opening = cv.morphologyEx(thresh, cv.MORPH_OPEN, kernel, iterations=2)

    # Dilate the opening to get the background
    sure_bg = cv.dilate(opening, kernel, iterations=3)

    # Calculate the distance transform
    dist_transform = cv.distanceTransform(opening, cv.DIST_L2, 5)

    # Threshold the distance transform to get the foreground
    _, sure_fg = cv.threshold(dist_transform, 0.2 * dist_transform.max(), 255, 0)
    sure_fg = np.uint8(sure_fg)

    # Find the unknown region
    unknown = cv.subtract(sure_bg, sure_fg)

    # Label the markers for watershed algorithm
    _, markers = cv.connectedComponents(sure_fg)
    markers = markers + 1
    markers[unknown == 255] = 0

    # Apply watershed algorithm
    markers = cv.watershed(img, markers)

    # Create a mask for the segmented region
    mask = np.zeros_like(gray, dtype=np.uint8)
    mask[markers == 1] = 255

    return mask

4. Segmentasi Berasaskan Pengelompokan

Teknik pengelompokan seperti K-Means cenderung untuk mengumpulkan piksel ke dalam kelompok yang serupa, yang berfungsi dengan baik apabila ingin membahagikan sel dalam persekitaran berbilang warna atau kompleks, seperti yang dilihat dalam imej sel HEp-2. Pada asasnya, ini boleh mewakili kelas yang berbeza, seperti rantau selular berbanding latar belakang.

K-means is an unsupervised learning algorithm for clustering images based on the pixel similarity of color or intensity. The algorithm randomly selects K centroids, assigns each pixel to the nearest centroid, and updates the centroid iteratively until it converges. It is particularly effective in segmenting an image that has multiple regions of interest that are very different from one another.

# Clustering Segmentation
def clustering(img):
    # Convert image to grayscale
    gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

    # Reshape the image
    Z = gray.reshape((-1, 3))
    Z = np.float32(Z)

    # Define the criteria for k-means clustering
    criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 10, 1.0)

    # Set the number of clusters
    K = 2

    # Perform k-means clustering
    _, label, center = cv.kmeans(Z, K, None, criteria, 10, cv.KMEANS_RANDOM_CENTERS)

    # Convert the center values to uint8
    center = np.uint8(center)

    # Reshape the result
    res = center[label.flatten()]
    res = res.reshape((gray.shape))

    # Apply thresholding to the result
    _, res = cv.threshold(res, 0, 255, cv.THRESH_BINARY + cv.THRESH_OTSU)

    return res

Evaluating the Techniques Using F1 Scores

The F1 score is a measure that combines precision and recall together to compare the predicted segmentation image with the ground truth image. It is the harmonic mean of precision and recall, which is useful in cases of high data imbalance, such as in medical imaging datasets.

We calculated the F1 score for each segmentation method by flattening both the ground truth and the segmented image and calculating the weighted F1 score.

def calculate_f1_score(ground_image, segmented_image):
    ground_image = ground_image.flatten()
    segmented_image = segmented_image.flatten()
    return f1_score(ground_image, segmented_image, average="weighted")

We then visualized the F1 scores of different methods using a simple bar chart:

Conclusion

Although many recent approaches for image segmentation are emerging, traditional segmentation techniques such as thresholding, edge detection, region-based methods, and clustering can be very useful when applied to datasets such as the MIVIA HEp-2 image dataset.

Each method has its strength:

• Thresholding is good for simple binary segmentation.
• Edge Detection is an ideal technique for the detection of boundaries.
• Region-based segmentation is very useful in separating connected components from their neighbors.
• Clustering methods are well-suited for multi-region segmentation tasks.

By evaluating these methods using F1 scores, we understand the trade-offs each of these models has. These methods may not be as sophisticated as what is developed in the newest models of deep learning, but they are still fast, interpretable, and serviceable in a broad range of applications.

Thanks for reading! I hope this exploration of traditional image segmentation techniques inspires your next project. Feel free to share your thoughts and experiences in the comments below!

Atas ialah kandungan terperinci Menguasai Segmentasi Imej: Cara Teknik Tradisional Masih Bersinar di Era Digital. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!