3D二值掩码图像孔洞填充求助：现有方法未达预期效果

Hey there! Let's troubleshoot why your hole-filling isn't working for that 3D binary mask and get those patches filled properly. Here are some common issues and fixes to try:

1. Check if your mask is strictly binary first #

First things first: make sure your input array only contains 0 and 1 values. If there are any other numbers (like 255 from a misread image), the fill functions might behave unexpectedly. You can validate this quickly:

print(np.unique(array_to_be_filled))

If you see values other than 0/1, clamp them first:

array_to_be_filled = np.where(array_to_be_filled > 0, 1, 0).astype(int)

2. Fix your SimpleITK usage (common mistake!) #

Your current SimpleITK code is passing a numpy array directly to sitk.BinaryFillhole, but that function expects a SimpleITK Image object, not a raw array. Here's the corrected workflow:

import SimpleITK as sitk
import numpy as np

# Convert numpy array to SimpleITK image
sitk_mask = sitk.GetImageFromArray(array_to_be_filled)
# Fill holes with fully connected 3D structure (adjust fullyConnected if needed)
filled_sitk_mask = sitk.BinaryFillhole(sitk_mask, fullyConnected=True)
# Convert back to numpy array
filled_array = sitk.GetArrayFromImage(filled_sitk_mask)

The fullyConnected=True flag ensures we use 3D full connectivity (6 faces + 12 edges + 8 corners) to detect holes, which is often needed for 3D masks.

3. Adjust scipy's connectivity for 3D #

While scipy.ndimage.binary_fill_holes supports 3D, sometimes explicitly defining the connectivity structure helps, especially if your holes are only connected via edges/corners. Try this:

from scipy.ndimage import binary_fill_holes, generate_binary_structure

# Create a 3D full connectivity structure (3x3x3 kernel with all 1s)
struct = generate_binary_structure(3, 3)
# Fill holes using this structure
filled_mask = binary_fill_holes(array_to_be_filled, structure=struct).astype(int)

If your holes are only present in 2D slices (not spanning 3D), you could also loop through each slice and apply 2D filling:

filled_mask = np.copy(array_to_be_filled)
for i in range(filled_mask.shape[0]):
    filled_mask[i] = binary_fill_holes(filled_mask[i]).astype(int)

4. Patch gaps in your mask first #

If your "holes" are actually connected to the background (because the patch has gaps in 3D), the fill functions won't recognize them as internal holes. Fix this with a 3D closing operation (dilation followed by erosion) to seal gaps before filling:

from scipy.ndimage import binary_closing, generate_binary_structure

# Use a 3D structure for closing (adjust the second parameter for connectivity: 2 = face-connected)
struct = generate_binary_structure(3, 2)
# Close gaps in the mask
closed_mask = binary_closing(array_to_be_filled, structure=struct, iterations=1).astype(int)
# Now fill the holes
filled_mask = binary_fill_holes(closed_mask).astype(int)

Adjust iterations if your gaps are larger (but be careful not to over-expand the patch).

5. Verify the holes are truly internal #

Double-check if the holes are fully enclosed by 1s in 3D. You can slice through your mask at different z-levels to see if there's any path from the hole to the background. If there is, the closing step above should fix that.

Give these steps a try—start with validating your mask and fixing the SimpleITK/scipy usage, then move to closing gaps if needed.

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