基于MST的图像分割：森林/分区向分割图像映射技术咨询

Hey there! Let's walk through how to map those MST forest partitions back into a proper segmented image—this is the final piece that turns all your graph work into a usable result, so let's make it practical.

You’ve already checked off the hard parts: converting color to grayscale, building the weighted graph, computing the MST, and cutting the top R-1 highest-cost edges to get R distinct tree regions. Now let’s tie this to the output image with these actionable steps:

1. Create a Pixel-to-Region Label Map #

First, you need a way to track which region (tree in the forest) each original pixel belongs to. The easiest way is to build a label array that matches the dimensions of your grayscale image:

• Initialize the array with a placeholder value (like -1) to mark unassigned pixels.
• Use BFS or DFS to traverse each tree in the forest. For every pixel in a tree, assign it a unique integer label (e.g., 0 to R-1). This ensures all pixels in the same region share the same label.

Example pseudocode (Python-style):

import numpy as np
from collections import deque

# Assume mst_adj is an adjacency list for your MST (post edge-cutting)
grayscale_shape = grayscale_image.shape
segment_labels = np.full(grayscale_shape, -1)
current_label = 0

# Iterate through every pixel to find unassigned regions
for y in range(grayscale_shape[0]):
    for x in range(grayscale_shape[1]):
        if segment_labels[y, x] == -1:
            # Start BFS to mark all pixels in this tree
            queue = deque([(y, x)])
            segment_labels[y, x] = current_label
            while queue:
                cy, cx = queue.popleft()
                # Check all MST neighbors of the current pixel
                for neighbor in mst_adj[(cy, cx)]:
                    ny, nx = neighbor
                    if segment_labels[ny, nx] == -1:
                        segment_labels[ny, nx] = current_label
                        queue.append((ny, nx))
            current_label += 1

2. Assign Average Weights to Regions #

You mentioned assigning the average weight to each tree’s vertices—here’s how to implement this for both grayscale and color outputs:

• Grayscale output: Calculate the mean grayscale value for each region using the label map. Then create an output image where every pixel is replaced with its region’s mean value.
• Color output (if you want to retain original color): Keep your original color image handy. Calculate the mean RGB value for each region using the original color pixels grouped by the label map, then map each label to its mean RGB value.

Example for grayscale:

segmented_image = np.zeros_like(grayscale_image)
for label in range(current_label):
    # Isolate all pixels in the current region
    region_mask = segment_labels == label
    # Compute the mean grayscale value for the region
    region_mean = np.mean(grayscale_image[region_mask])
    # Assign the mean value to all pixels in the region
    segmented_image[region_mask] = region_mean

3. Edge Cases & Optimizations #

• Label consistency: Double-check that you have exactly R unique labels (matching your input region count) to avoid gaps or extra regions.
• Speed for large images: For big datasets, use vectorized operations (like NumPy’s built-in functions) instead of nested loops. Tools like scipy.ndimage.mean can compute region means directly using the label array, which is much faster.
• Boundary visualization: If you want to highlight segmentation boundaries instead of filling regions, create a mask where adjacent pixels have different labels, then overlay those boundaries on the original image.

4. Verify Your Mapping #

To make sure everything works:

• Check that the number of unique labels in segment_labels equals R.
• Spot-test a few pixels: Pick a pixel in the original image, find its label, and confirm it’s grouped with neighboring pixels that logically belong to the same region (based on your MST’s edge weights).

内容的提问来源于stack exchange，提问作者BaraDos