如何去除图像噪声？Swift实现膨胀/腐蚀算法降噪求助

首先得先理清用膨胀还是腐蚀的适用场景：

• 如果你的背景噪声是黑色小点（暗噪声）：用膨胀（Dilation），它会扩大亮区域，填充暗噪声
• 如果是白色小点（亮噪声）：用腐蚀（Erosion），它会缩小亮区域，消除亮噪声

先来看你提到的图像：

• 未滤波的含噪图像：
• 滤波后的预期效果：

OpenCV参考示例（你提到的代码） #

假设你的OpenCV代码大概是这样的（常见的形态学滤波实现）：

#include <opencv2/opencv.hpp>

using namespace cv;

int main() {
    Mat src = imread("noisy_image.png", IMREAD_GRAYSCALE);
    if (src.empty()) return -1;
    
    // 创建3x3矩形结构元素
    Mat kernel = getStructuringElement(MORPH_RECT, Size(3, 3));
    
    Mat dst;
    // 去除暗噪声用膨胀
    dilate(src, dst, kernel);
    // 去除亮噪声用腐蚀
    // erode(src, dst, kernel);
    
    imwrite("filtered_image.png", dst);
    return 0;
}

Swift实现方案 #

下面给你两种Swift实现方式，推荐用Core Image的方案，高效且简洁；手动实现适合理解原理。

方案1：用Core Image框架实现（推荐） #

Core Image自带了形态学滤波的滤镜，CIMorphologyRectangleMaximum对应膨胀，CIMorphologyRectangleMinimum对应腐蚀，代码如下：

import UIKit
import CoreImage

/// 应用形态学滤波（膨胀/腐蚀）到图像
/// - Parameters:
///   - image: 输入的含噪图像
///   - isDilation: true=膨胀（处理暗噪声），false=腐蚀（处理亮噪声）
/// - Returns: 滤波后的图像，失败返回nil
func applyMorphologicalFilter(to image: UIImage, isDilation: Bool) -> UIImage? {
    guard let ciImage = CIImage(image: image),
          let filterName = isDilation ? "CIMorphologyRectangleMaximum" : "CIMorphologyRectangleMinimum" else {
        return nil
    }
    
    let filter = CIFilter(name: filterName)!
    filter.setValue(ciImage, forKey: kCIInputImageKey)
    // 调整半径（内核大小），3是常用值，噪声大可以调大，比如5
    filter.setValue(3, forKey: kCIInputRadiusKey)
    
    guard let outputCIImage = filter.outputImage else {
        return nil
    }
    
    // 渲染输出图像
    let context = CIContext(options: [.useSoftwareRenderer: false])
    guard let outputCGImage = context.createCGImage(outputCIImage, from: outputCIImage.extent) else {
        return nil
    }
    
    return UIImage(cgImage: outputCGImage)
}

// 使用示例
if let noisyImage = UIImage(named: "noisy_image"),
   let filteredImage = applyMorphologicalFilter(to: noisyImage, isDilation: true) {
    // 这里可以把filteredImage显示到UIImageView或者保存到本地
    // imageView.image = filteredImage
}

方案2：手动实现像素级形态学滤波（适合学习原理） #

如果想自己处理像素逻辑，下面是手动实现3x3内核的膨胀/腐蚀代码：

import UIKit

/// 手动实现像素级膨胀/腐蚀
/// - Parameters:
///   - image: 输入图像
///   - isDilation: true=膨胀，false=腐蚀
/// - Returns: 处理后的图像
func applyManualMorphology(to image: UIImage, isDilation: Bool) -> UIImage? {
    guard let cgImage = image.cgImage,
          let dataProvider = cgImage.dataProvider,
          let pixelData = dataProvider.data,
          let mutablePixelData = CFDataCreateMutableCopy(nil, 0, pixelData) else {
        return nil
    }
    
    let width = cgImage.width
    let height = cgImage.height
    let bytesPerPixel = 4 // RGBA格式
    let bytesPerRow = cgImage.bytesPerRow
    let pixels = mutablePixelData.mutableBytes.assumingMemoryBound(to: UInt8.self)
    
    // 3x3内核，取中心像素周围8个邻域+自身
    let kernelSize = 3
    let halfKernel = kernelSize / 2
    
    // 创建临时数组存储处理后的数据，避免处理时覆盖原始像素
    var tempPixels = [UInt8](repeating: 0, count: width * height * bytesPerPixel)
    
    for y in 0..<height {
        for x in 0..<width {
            let baseIndex = y * bytesPerRow + x * bytesPerPixel
            
            // 初始化极值：膨胀取邻域最大值，腐蚀取邻域最小值
            var red: UInt8 = isDilation ? 0 : 255
            var green: UInt8 = isDilation ? 0 : 255
            var blue: UInt8 = isDilation ? 0 : 255
            
            // 遍历邻域像素
            for ky in -halfKernel...halfKernel {
                for kx in -halfKernel...halfKernel {
                    let neighborY = y + ky
                    let neighborX = x + kx
                    
                    // 边界检查，避免越界访问
                    guard neighborY >= 0, neighborY < height, neighborX >= 0, neighborX < width else {
                        continue
                    }
                    
                    let neighborIndex = neighborY * bytesPerRow + neighborX * bytesPerPixel
                    let neighborR = pixels[neighborIndex]
                    let neighborG = pixels[neighborIndex + 1]
                    let neighborB = pixels[neighborIndex + 2]
                    
                    if isDilation {
                        red = max(red, neighborR)
                        green = max(green, neighborG)
                        blue = max(blue, neighborB)
                    } else {
                        red = min(red, neighborR)
                        green = min(green, neighborG)
                        blue = min(blue, neighborB)
                    }
                }
            }
            
            // 赋值到临时数组，保留原始alpha通道
            tempPixels[baseIndex] = red
            tempPixels[baseIndex + 1] = green
            tempPixels[baseIndex + 2] = blue
            tempPixels[baseIndex + 3] = pixels[baseIndex + 3]
        }
    }
    
    // 创建新的CGImage
    guard let colorSpace = cgImage.colorSpace else {
        return nil
    }
    let bitmapInfo = cgImage.bitmapInfo
    
    guard let context = CGContext(data: &tempPixels,
                                  width: width,
                                  height: height,
                                  bitsPerComponent: 8,
                                  bytesPerRow: bytesPerRow,
                                  space: colorSpace,
                                  bitmapInfo: bitmapInfo.rawValue) else {
        return nil
    }
    
    guard let outputCGImage = context.makeImage() else {
        return nil
    }
    
    return UIImage(cgImage: outputCGImage)
}

// 使用示例
if let noisyImage = UIImage(named: "noisy_image"),
   let filteredImage = applyManualMorphology(to: noisyImage, isDilation: false) {
    // 使用处理后的图像
}

你的代码可能出问题的原因 #

如果你的Swift代码没正常工作，大概率是这几个原因：

1. 搞反了膨胀/腐蚀的适用场景：比如暗噪声用了腐蚀，反而让噪声更明显；亮噪声用了膨胀，把噪声放大了
2. 内核大小设置不合理：半径太小的话，噪声没被完全消除；半径太大，会把目标物体也模糊了
3. 边界处理错误：手动处理像素时没做边界检查，导致越界访问，出现异常或者图像边缘错乱
4. 忽略了alpha通道：处理像素时没保留alpha，导致图像透明度异常

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