图像直方图：从频率分布到智能决策

一、直方图的定义与信息密度

图像直方图本质上是像素值的频率分布统计图——它精确记录了每个亮度级（0至255）在图像中出现的频次。

一张 640×480（307200 像素）的图像，亮度直方图（横轴 0–255）：计数
 ↑
 █                 假设这是一张低对比度的雾天照片：
 █  ████            - 像素值高度集中在 100–180，左右两端近乎无数据
 █ ██████           - 表现特征：图像"灰蒙蒙一片"，缺乏纯黑与纯白区域
 ███████████████
 0              255 → 像素值

从直方图能提取哪些关键信息？下表为你清晰呈现：

二、RGB + 亮度四通道直方图

HistogramAnalyzer 分析器会同步计算 R、G、B 三个颜色通道以及亮度（Luma）通道的直方图，总计包含 4 × 256 = 1024 个计数桶。

BT.709 亮度公式

人眼对绿色光谱分量最为敏感，对蓝色则最不敏感。BT.709（HDTV 标准）定义的加权亮度计算公式如下：

Y = 0.2126×R + 0.7152×G + 0.0722×B

在实际编码实现中，我们采用整数近似运算来规避浮点乘法的性能开销，实测提速效果可达3倍左右：

// 0.2126 ≈ 54/256, 0.7152 ≈ 183/256, 0.0722 ≈ 18/256
// 注意：54 + 183 + 18 = 255，使用 >> 8 代替除以 256
@inline(__always)
func luma(r: UInt8, g: UInt8, b: UInt8) -> UInt8 {
    let y = 54 * UInt16(r) + 183 * UInt16(g) + 18 * UInt16(b)
    return UInt8(y >> 8)   // 等效于除以 256，完成自动舍入
}

为什么选用 >> 8 而不是 / 256？Swift 编译器在 Release 模式下会自动完成优化，但在 Debug 模式下，位运算 >> 速度更快且语义更明确——这是定点数运算的经典技巧，并非简单的除法。

三、核心统计量的计算

HistogramAnalyzer 会对每个通道计算 5 个关键的统计量：

3.1 均值（Mean）

func mean(histogram: [Int], totalPixels: Int) -> Double {
    let sum = histogram.enumerated().reduce(0) { acc, pair in
        acc + pair.offset * pair.element
    }
    return Double(sum) / Double(totalPixels)
}

均值直接反映图像的平均亮度水平。通常来说，均值低于100意味着欠曝风险，高于160则表明出现过曝。

3.2 标准差（Std Dev）

func stdDev(histogram: [Int], mean: Double, totalPixels: Int) -> Double {
    let variance = histogram.enumerated().reduce(0.0) { acc, pair in
        let diff = Double(pair.offset) - mean
        return acc + diff * diff * Double(pair.element)
    }
    return sqrt(variance / Double(totalPixels))
}

标准差是量化图像对比度的关键指标。标准差低于20表示对比度过低，图像显得扁平；高于60则意味着对比度相当高。

3.3 中位数（Median）——通过累积分布来求

func median(histogram: [Int], totalPixels: Int) -> Int {
    let target = totalPixels / 2
    var cumulative = 0
    for (value, count) in histogram.enumerated() {
        cumulative += count
        if cumulative >= target {
            return value   // 累积分布首次超过 50% 的像素值
        }
    }
    return 255
}

与均值相比，中位数具有更强的鲁棒性。举例来说，即使画面中有一小块过曝区域（数百个像素值为255），均值会被明显拉高，但中位数几乎不受影响。

3.4 香农熵（Shannon Entropy）

func entropy(histogram: [Int], totalPixels: Int) -> Double {
    let n = Double(totalPixels)
    return histogram.reduce(0.0) { acc, count in
        guard count > 0 else { return acc }
        let p = Double(count) / n
        return acc - p * log2(p)   // 香农熵公式：-Σ p·log₂(p)
    }
}

熵的单位为 bits，它量化了平均每个像素需要多少比特信息才能描述其亮度值。

为什么熵在图像质量评估中至关重要？因为压缩效率与信息熵直接挂钩。一张熵值接近8 bits的图像（接近均匀分布），表明所有亮度值出现的概率大致相等，JPEG压缩率会极差（几乎没有冗余可压缩）。相反，熵值在3–5 bits的图像包含大量冗余，压缩率会相当可观。

四、Otsu 阈值算法完整推导

Otsu 算法旨在自动寻找最优二值化阈值，其核心目标是最大化类间方差——即使得背景像素组与前景像素组之间的差异达到最大。

4.1 为什么用类间方差，而不用类内方差？

类内方差 = 每组内部的像素值离散程度
  → 最小化类内方差 = 让每组像素值尽可能聚集（聚类效果）类间方差 = 两组均值的差异程度
  → 最大化类间方差 = 让两组数据尽可能分离数学恒等式：总方差 = 类内方差 + 类间方差
  ∴ 最大化类间方差 ≡ 最小化类内方差
  但类间方差仅需 2 个参数（两组的均值与权重），计算复杂度为 O(256)
  类内方差则需要遍历全部像素，计算复杂度为 O(N)
  → Otsu 选择类间方差，因为计算效率显著更高

4.2 类间方差公式推导

假设我们设定阈值为 t（0–255），则所有像素可分为两类：

• 背景（Background）：像素值 ≤ t
• 前景（Foreground）：像素值 > t

对于阈值 t，计算公式如下：

ωB(t) = Σ_{i=0}^{t} p(i)          背景像素的占比
ωF(t) = Σ_{i=t+1}^{255} p(i)     前景像素的占比（= 1 - ωB）μB(t) = Σ_{i=0}^{t} i·p(i) / ωB  背景像素的平均值
μF(t) = Σ_{i=t+1}^{255} i·p(i) / ωF   前景像素的平均值类间方差：
σ²_B(t) = ωB × ωF × (μB - μF)²

Otsu 算法的精髓在于：遍历所有可能的 t（从0到254），然后选取使 σ²_B(t) 达到最大的那个值。

4.3 Swift 实现

func otsuThreshold(histogram: [Int], totalPixels: Int) -> Int {
    let n = Double(totalPixels)    // 预计算：全局总均值
    let totalMean = (0..<256).reduce(0.0) { $0 + Double($1) * Double(histogram[$1]) / n }    var maxVariance = 0.0
    var bestThreshold = 128   // 默认阈值    var omegaB = 0.0   // 背景比例（累积计算）
    var muB    = 0.0   // 背景均值×背景比例的累积值（便于更新）    for t in 0..<255 {
        omegaB += Double(histogram[t]) / n
        muB    += Double(t) * Double(histogram[t]) / n        let omegaF = 1.0 - omegaB
        guard omegaB > 0, omegaF > 0 else { continue }        // 前景均值 = (全局总均值×1 - 背景均值×背景比例) / 前景比例
        let meanBg = muB / omegaB
        let meanFg = (totalMean - muB) / omegaF        let variance = omegaB * omegaF * (meanBg - meanFg) * (meanBg - meanFg)
        if variance > maxVariance {
            maxVariance = variance
            bestThreshold = t
        }
    }
    return bestThreshold
}

时间复杂度：O(N + 256)，实际可视为 O(N)。因为我们只需先对图像进行一次扫描来构建直方图（O(N)），然后遍历256个潜在阈值（O(256)，属于常数级别）。

五、归一化 CDF——手动直方图均衡

**直方图均衡（Histogram Equalization）**的目标明确：将直方图的任意分布转换为均匀分布，从而最大化图像对比度。

原始直方图（集中在中间）：   均衡后的直方图（近似均匀分布）：
    ████                          ██ ██ ██ ██ ██ ██ ██ ██ ██
 ██████████                      ██ ██ ██ ██ ██ ██ ██ ██ ██
─────────────                   ─────────────────────────────
0          255                  0                           255

这个均衡变换的核心是**归一化累积分布函数（CDF）**：

func buildEqualizedLUT(histogram: [Int], totalPixels: Int) -> [UInt8] {
    // Step 1：构建 CDF
    var cdf = [Int](repeating: 0, count: 256)
    cdf[0] = histogram[0]
    for i in 1..<256 {
        cdf[i] = cdf[i - 1] + histogram[i]
    }    // Step 2：找到 CDF 的最小非零值（用于归一化）
    let cdfMin = cdf.first(where: { $0 > 0 }) ?? 1    // Step 3：生成查找表（LUT）
    // 公式：equalized(v) = round((cdf(v) - cdfMin) / (N - cdfMin) × 255)
    return (0..<256).map { v in
        let numerator = cdf[v] - cdfMin
        let denominator = totalPixels - cdfMin
        if denominator <= 0 { return UInt8(v) }
        return UInt8(min(255, numerator * 255 / denominator))
    }
}// 应用 LUT 到图像
func applyLUT(_ lut: [UInt8], to bitmap: inout MLBitmap) {
    for i in stride(from: 0, to: bitmap.pixels.count, by: 4) {
        bitmap.pixels[i]     = lut[Int(bitmap.pixels[i])]     // R 通道
        bitmap.pixels[i + 1] = lut[Int(bitmap.pixels[i + 1])] // G 通道
        bitmap.pixels[i + 2] = lut[Int(bitmap.pixels[i + 2])] // B 通道
        // Alpha 通道保持不变
    }
}

这里需要特别提醒：对 RGB 三通道分别独立做均衡，会导致明显的颜色偏移。正确的做法是只对亮度通道（例如 HSV 色彩空间中的 V 分量，或 Lab 空间中的 L 分量）进行均衡，从而保持色相不变。

六、实际应用：图像质量评估

HistogramAnalyzer 是 Phase 1 中 estimateQuality（Day 9）的升级版，通过多维度的量化指标来综合评估图像质量：

struct ImageQualityReport {
    let lumaEntropy: Double      // 亮度熵：度量信息含量（bits）
    let contrast:    Double      // 对比度：亮度标准差
    let exposure:    Double      // 曝光偏差：均值偏离 128 的程度
    let otsuThresh:  Int         // Otsu 阈值：用于判断前景/背景分界    /// 综合质量评分（0–100）
    var qualityScore: Int {
        var score = 100.0        // 曝光扣分：均值偏离 128 超过 40 时开始扣分
        let exposurePenalty = max(0, abs(exposure - 128) - 40) * 0.5
        score -= exposurePenalty        // 对比度扣分：标准差 < 20 视为低对比度
        if contrast < 20 { score -= (20 - contrast) * 1.5 }        // 信息量扣分：熵 < 4 视为内容单调
        if lumaEntropy < 4 { score -= (4 - lumaEntropy) * 5 }        return max(0, min(100, Int(score.rounded())))
    }
}

动态 JPEG 质量（与 Day 9 联动）：

func recommendJPEGQuality(report: ImageQualityReport) -> Int {
    // 高信息量图像：使用高质量编码，避免信息损失
    if report.lumaEntropy > 6.5 { return 92 }
    // 低对比度图像（如纯色背景）：可接受低质量编码（低熵意味着高压缩率）
    if report.contrast < 25 { return 72 }
    return 85   // 默认压缩质量
}

七、HistogramAnalyzer 的完整实现结构

public struct HistogramAnalyzer {    public struct ChannelStats {
        public let histogram: [Int]   // 256 个计数桶
        public let mean:      Double
        public let stdDev:    Double
        public let median:    Int
        public let entropy:   Double
    }    public struct Result {
        public let r, g, b, luma: ChannelStats
        public let otsuThreshold: Int   // 基于亮度直方图计算的 Otsu 阈值
        public let normalizedCDF: [Double]   // 归一化 CDF（用于直方图均衡化）
    }    public static func analyze(_ bitmap: MLBitmap) -> Result {
        // Phase 1：单次扫描，同步更新 4 个通道的 256 桶计数
        var rHist  = [Int](repeating: 0, count: 256)
        var gHist  = [Int](repeating: 0, count: 256)
        var bHist  = [Int](repeating: 0, count: 256)
        var yHist  = [Int](repeating: 0, count: 256)
        let total  = bitmap.width * bitmap.height        for i in stride(from: 0, to: bitmap.pixels.count, by: 4) {
            let r = bitmap.pixels[i]
            let g = bitmap.pixels[i + 1]
            let b = bitmap.pixels[i + 2]
            let y = UInt8((54 * UInt16(r) + 183 * UInt16(g) + 18 * UInt16(b)) >> 8)
            rHist[Int(r)] += 1
            gHist[Int(g)] += 1
            bHist[Int(b)] += 1
            yHist[Int(y)] += 1
        }        // Phase 2：对每个直方图分别计算统计量（4 次独立计算）
        func stats(_ hist: [Int]) -> ChannelStats { /* ... */ }        let otsu = otsuThreshold(histogram: yHist, totalPixels: total)
        let cdf  = buildNormalizedCDF(histogram: yHist, totalPixels: total)        return Result(r: stats(rHist), g: stats(gHist), b: stats(bHist),
                      luma: stats(yHist), otsuThreshold: otsu, normalizedCDF: cdf)
    }
}

最后，必须强调单次扫描的实战价值。对于一张1200万像素的图像，单次扫描意味着4800万次内存读取。如果分别对 R、G、B、Y 四个通道各扫描一次，总读取量会膨胀4倍，内存带宽将成为性能瓶颈。通过单次扫描将4个通道的计数合并处理，内存访问量保持不变，处理时间大约能缩减3倍。

八、小结