Swift图像处理：UIImage纹理值（Double）计算的实现难题

我帮你梳理并解决这三个问题，直接上可运行的修正方案，一步步来：

1. 修正Square结构体定义 #

首先要解决的是Square无法正确定位3×3方块的问题。我们让Square依赖图像的像素数据（一维数组，iOS中图像像素通常按行存储），通过左上角坐标计算出对应区域的所有像素：

import UIKit

// 保留你已有的RGBA和Pixel结构体，补充灰度值计算
struct RGBA {
    var red: UInt8
    var green: UInt8
    var blue: UInt8
    var alpha: UInt8
}

struct Pixel {
    var x: Int
    var y: Int
    var rgba: RGBA
    
    // 使用*ITU-R BT.601标准公式*计算灰度值，这是行业通用的灰度转换方式
    var grayscale: Double {
        return 0.299 * Double(rgba.red) + 0.587 * Double(rgba.green) + 0.114 * Double(rgba.blue)
    }
}

// 修正后的Square结构体：能正确获取左上角(x,y)对应的3×3像素
struct Square {
    let topLeftX: Int
    let topLeftY: Int
    let pixelData: [RGBA]
    let imageWidth: Int
    
    init(topLeftX: Int, topLeftY: Int, pixelData: [RGBA], imageWidth: Int) {
        self.topLeftX = topLeftX
        self.topLeftY = topLeftY
        self.pixelData = pixelData
        self.imageWidth = imageWidth
    }
    
    // 懒加载当前方块内的所有3×3像素，做边界保护避免越界
    var pixels: [Pixel] {
        var squarePixels = [Pixel]()
        for yOffset in 0..<3 {
            for xOffset in 0..<3 {
                let currentX = topLeftX + xOffset
                let currentY = topLeftY + yOffset
                let pixelIndex = currentY * imageWidth + currentX
                guard pixelIndex < pixelData.count else { continue }
                squarePixels.append(Pixel(x: currentX, y: currentY, rgba: pixelData[pixelIndex]))
            }
        }
        return squarePixels
    }
}

2. 实现并可测试的getSquareDifference函数 #

现在Square能正确返回3×3像素了，我们可以实现差值计算函数，还能轻松写测试用例验证：

// 计算单个方块的灰度值最大最小差
func getSquareDifference(_ square: Square) -> Double {
    guard !square.pixels.isEmpty else { return 0 }
    
    let grayscaleValues = square.pixels.map { $0.grayscale }
    guard let maxGray = grayscaleValues.max(), let minGray = grayscaleValues.min() else { return 0 }
    return maxGray - minGray
}

// 测试用例：验证差值计算是否正确
func testSquareDifference() {
    // 构造一个包含黑色和白色的测试方块
    var testPixels = [RGBA](repeating: RGBA(red: 0, green: 0, blue: 0, alpha: 255), count: 9)
    testPixels[4] = RGBA(red: 255, green: 255, blue: 255, alpha: 255) // 中间像素为白色
    
    let testSquare = Square(topLeftX: 0, topLeftY: 0, pixelData: testPixels, imageWidth: 3)
    let difference = getSquareDifference(testSquare)
    print("测试差值：\(difference)") // 预期输出255.0，符合逻辑
}

3. 修正determineTexture的循环遍历逻辑 #

最后调整循环，确保遍历所有200×200个方块，并且正确累加差值。这里先把UIImage转换成像素数据数组，再按3×3步长遍历：

// 计算图像总纹理值：输入UIImage，返回Double类型总差值
func determineTexture(from inputImage: UIImage) -> Double {
    // 确保图像是600×600（使用你提供的SDWebImage方法）
    guard let compressedImage = inputImage.sd_resizedImage(with: CGSize(width: 600, height: 600), scaleMode: .aspectFill),
          let cgImage = compressedImage.cgImage else {
        return 0
    }
    
    let imageWidth = cgImage.width
    let imageHeight = cgImage.height
    let bytesPerPixel = 4
    let bytesPerRow = bytesPerPixel * imageWidth
    let bitsPerComponent = 8
    
    // 创建像素数据缓冲区
    var pixelData = [RGBA](repeating: RGBA(red: 0, green: 0, blue: 0, alpha: 0), count: imageWidth * imageHeight)
    
    // 通过CGContext获取图像的RGBA像素数据
    let colorSpace = CGColorSpaceCreateDeviceRGB()
    guard let context = CGContext(data: &pixelData,
                                  width: imageWidth,
                                  height: imageHeight,
                                  bitsPerComponent: bitsPerComponent,
                                  bytesPerRow: bytesPerRow,
                                  space: colorSpace,
                                  bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue) else {
        return 0
    }
    
    context.draw(cgImage, in: CGRect(x: 0, y: 0, width: imageWidth, height: imageHeight))
    
    var totalTexture = 0.0
    let squareSize = 3
    let totalSquaresPerSide = imageWidth / squareSize // 600/3=200
    
    // 遍历所有200×200个方块：x和y从0到199，每个方块左上角坐标为(x*3, y*3)
    for y in 0..<totalSquaresPerSide {
        for x in 0..<totalSquaresPerSide {
            let topLeftX = x * squareSize
            let topLeftY = y * squareSize
            let square = Square(topLeftX: topLeftX, topLeftY: topLeftY, pixelData: pixelData, imageWidth: imageWidth)
            totalTexture += getSquareDifference(square)
        }
    }
    
    return totalTexture
}

关键说明 #

• 像素数据转换：通过CGContext将UIImage转成一维RGBA数组，这是iOS中获取图像像素的标准方式
• 循环逻辑：每个方块的左上角坐标是x*3和y*3，x/y从0到199，确保覆盖整个600×600图像，无重叠无遗漏
• 边界保护：在Square的pixels计算中加入越界判断，避免图像边缘（如果有尺寸误差）的崩溃问题

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