将C# fiducial marker生成代码迁移至Python时，OpenCV腐蚀（Erode）与膨胀（Dilate）效果匹配问题求助

我仔细分析了你提到的C#自定义形态学操作代码，问题的核心在于OpenCV内置的erode/dilate和你的C#实现逻辑完全不同：前者是基于极值滤波，后者是基于掩码区域内的像素投票阈值。下面是完全匹配C#效果的Python实现方案：

一、先明确C#自定义函数的核心逻辑 #

你的C#代码里的腐蚀/膨胀不是标准形态学操作，而是一种投票式的自定义滤波，具体规则：

1. 掩码：半径12的圆形区域，排除中心像素（只统计周围的圆形邻域）
2. 腐蚀（erodeBitmap）：对每个像素，统计掩码区域内非黑像素的数量，如果数量≤掩码总像素数的一半，当前像素设为黑
3. 膨胀（dilateBitmap）：对每个像素，统计掩码区域内非黑像素的数量，如果数量≥掩码总像素数的一半，当前像素设为白
4. 每次处理都基于上一步的图像副本计算，而非原地修改

二、Python实现代码 #

1. 生成匹配的球形掩码 #

首先复刻C#的generateBallMask函数：

import numpy as np
from skimage.util import view_as_windows  # 用于加速，可选

def generate_ball_mask(rad):
    size = 2 * rad + 1
    mask = np.zeros((size, size), dtype=bool)
    for i in range(size):
        for j in range(size):
            dx = i - rad
            dy = j - rad
            # 圆形区域 + 排除中心像素
            if dx*dx + dy*dy <= rad*rad and not (dx == 0 and dy == 0):
                mask[i, j] = True
    return mask

2. 自定义腐蚀函数（匹配C# erodeBitmap） #

这里提供两种版本：基础循环版（易理解）和快速向量化版（适合大图像）

基础循环版

def custom_erode(img, rad):
    # 输入img为二值图像（0=黑，255=白）
    mask = generate_ball_mask(rad)
    mask_total = np.sum(mask)
    threshold = mask_total // 2
    pad = rad  # 边界填充宽度，避免越界
    # 对图像进行边界填充，填充值为黑（0）
    padded_img = np.pad(img, pad_width=pad, mode='constant', constant_values=0)
    h, w = img.shape
    result = img.copy()
    
    for y in range(h):
        for x in range(w):
            # 提取当前像素对应的掩码区域
            roi = padded_img[y:y+2*pad+1, x:x+2*pad+1]
            # 统计掩码区域内的非黑像素数量
            non_black_count = np.sum(roi[mask] == 255)
            # 应用腐蚀规则
            if non_black_count <= threshold:
                result[y, x] = 0
    return result

快速向量化版（推荐）

用滑动窗口替代双重循环，速度提升数十倍：

def custom_erode_fast(img, rad):
    mask = generate_ball_mask(rad)
    mask_total = np.sum(mask)
    threshold = mask_total // 2
    pad = rad
    padded_img = np.pad(img, pad_width=pad, mode='constant', constant_values=0)
    
    # 创建滑动窗口，每个窗口对应一个像素的掩码区域
    windows = view_as_windows(padded_img, (2*pad+1, 2*pad+1))
    # 批量统计每个窗口内掩码区域的非黑像素数量
    non_black_counts = np.sum(windows[:, :, mask] == 255, axis=2)
    
    result = img.copy()
    # 批量应用腐蚀规则
    result[non_black_counts <= threshold] = 0
    return result

3. 自定义膨胀函数（匹配C# dilateBitmap） #

同样提供两种版本：

基础循环版

def custom_dilate(img, rad):
    mask = generate_ball_mask(rad)
    mask_total = np.sum(mask)
    threshold = mask_total // 2
    pad = rad
    padded_img = np.pad(img, pad_width=pad, mode='constant', constant_values=0)
    h, w = img.shape
    result = img.copy()
    
    for y in range(h):
        for x in range(w):
            roi = padded_img[y:y+2*pad+1, x:x+2*pad+1]
            non_black_count = np.sum(roi[mask] == 255)
            # 应用膨胀规则
            if non_black_count >= threshold:
                result[y, x] = 255
    return result

快速向量化版（推荐）

def custom_dilate_fast(img, rad):
    mask = generate_ball_mask(rad)
    mask_total = np.sum(mask)
    threshold = mask_total // 2
    pad = rad
    padded_img = np.pad(img, pad_width=pad, mode='constant', constant_values=0)
    
    windows = view_as_windows(padded_img, (2*pad+1, 2*pad+1))
    non_black_counts = np.sum(windows[:, :, mask] == 255, axis=2)
    
    result = img.copy()
    result[non_black_counts >= threshold] = 255
    return result

4. 匹配C#的调用逻辑 #

按照你的描述，半径设为12，循环5次执行膨胀+腐蚀：

# 假设preprocessed_img是和C#预处理完全一致的二值图像
current_img = preprocessed_img.copy()
rad = 12

for _ in range(5):
    # 先执行膨胀，再执行腐蚀，和C#调用顺序一致
    current_img = custom_dilate_fast(current_img, rad)
    current_img = custom_erode_fast(current_img, rad)

三、为什么OpenCV内置函数不行？ #

OpenCV的cv2.erode/cv2.dilate是标准形态学操作：

• erode：取结构元素内的最小值（只要邻域内有黑像素，当前像素就变黑）
• dilate：取结构元素内的最大值（只要邻域内有白像素，当前像素就变白）
  这和你C#代码里的投票阈值逻辑完全不同，所以必然得到不同的结果。

四、验证注意事项 #

1. 确保输入的预处理图像和C#完全一致（二值化阈值、图像尺寸、像素格式都要匹配）
2. 如果用快速版，需要先安装scikit-image：pip install scikit-image
3. 测试时可以先单步执行一次膨胀/腐蚀，对比C#的中间结果，确认逻辑一致

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