C++图像分割：去除内部冗余像素以获取正确Freeman链码

Hey there, let's tackle this internal white pixel issue that's messing up your Freeman chain code results. I've dealt with similar segmentation artifacts before, so here are some practical, actionable approaches you can try:

1. Morphological Closing (Erosion + Dilation) #

This is my go-to for filling small internal holes without warping the target boundary too much. Morphological closing works by first eroding the image to shrink noise, then dilating it back to restore the original region size—effectively closing up tiny gaps or stray pixels inside the target.

• Use a small structuring element (3x3 square or disk is usually ideal) to avoid altering your actual target shape.
• Example Python code with OpenCV:

  import cv2
  import numpy as np
  
  # Load your segmented binary image (0 = background, 255 = foreground)
  segmented_img = cv2.imread("your_segmented_image.png", 0)
  
  # Define a 3x3 square structuring element
  kernel = np.ones((3, 3), np.uint8)
  
  # Apply closing operation to fill internal holes
  cleaned_img = cv2.morphologyEx(segmented_img, cv2.MORPH_CLOSE, kernel)
  

2. Connected Component Analysis #

If those internal white pixels are small, disconnected noise blobs, isolating the largest connected component (your actual target region) will eliminate them entirely.

• Steps to implement:
  • Detect all connected components in the binary image.
  • Calculate the area of each component.
  • Keep only the component with the largest area (assuming your target is the biggest region in the image).
• Example code snippet:

  # Find connected components with stats (area, position, etc.)
  num_labels, labels, stats, _ = cv2.connectedComponentsWithStats(segmented_img, connectivity=8)
  
  # Skip the background label (0) and find the largest foreground component
  largest_component_idx = 1 + np.argmax(stats[1:, cv2.CC_STAT_AREA])
  
  # Create a clean mask with only the largest component
  cleaned_img = np.zeros_like(segmented_img)
  cleaned_img[labels == largest_component_idx] = 255
  

3. Flood Fill for Hole Filling #

If the internal pixels are enclosed "holes" surrounded by your target region, flood filling from the image borders can mark all background areas, leaving only the holes to fill.

• How it works:
  • Start flood filling from all edge pixels (which should be background) to label every reachable background pixel.
  • Any remaining unlabeled pixels are internal holes—set these to foreground to fill them.
• Example code:

  flood_mask = segmented_img.copy()
  height, width = flood_mask.shape
  
  # Flood fill from all edge pixels to mark background
  for y in range(height):
      for x in [0, width - 1]:
          if flood_mask[y, x] == 0:
              cv2.floodFill(flood_mask, None, (x, y), 127)
  for x in range(width):
      for y in [0, height - 1]:
          if flood_mask[y, x] == 0:
              cv2.floodFill(flood_mask, None, (x, y), 127)
  
  # Convert mask back to binary: fill holes by setting unmarked pixels to foreground
  cleaned_img = np.where(flood_mask == 255, 255, 0).astype(np.uint8)
  

4. Median Blur + Re-Thresholding #

Sometimes internal noise comes from incomplete segmentation. A quick median blur can smooth out tiny white pixels, followed by re-thresholding to get a crisp binary image.

• Example:

  # Apply median blur to reduce small noise
  blurred_img = cv2.medianBlur(segmented_img, 3)
  
  # Re-threshold to restore sharp binary edges
  _, cleaned_img = cv2.threshold(blurred_img, 127, 255, cv2.THRESH_BINARY)
  

A quick tip: Test these methods on your specific image—since the root cause of internal pixels can vary (e.g., noisy input, segmentation algorithm limitations), you might need to combine techniques (like morphological closing + connected components) for the best result. Once you have the cleaned binary image, your Freeman chain code generation should work as expected!

内容的提问来源于stack exchange，提问作者Ugur Ç.