Kotlin Android中DCT与IDCT变换无法还原原始数值问题求助

你的DCT和IDCT无法还原原始值，核心问题在于变换系数的错误重复缩放以及精度处理不当，以下是具体修复步骤：

1. 核心问题点 #

• DCT重复应用正交系数：标准DCT-II公式中，正交系数α(u)/α(v)只需在求和后应用一次，但你在求和阶段额外乘了一次cu/cv（与α(u)/α(v)等价），导致系数被错误缩放了两次，正逆变换的缩放因子无法抵消。
• 精度丢失：直接用toInt()截断小数部分，会丢失浮点数计算的微小精度，导致还原值偏差。

2. 修复后的代码 #

修正后的DCT函数

返回原始DCT系数（而非直接调用IDCT），便于单独验证：

private fun applyDCT(block: Array<Int>): Array<DoubleArray> {
    val dctResult = Array(8) { DoubleArray(8) }
    for (u in 0 until 8) {
        for (v in 0 until 8) {
            var sum = 0.0
            // 只计算一次正交系数
            val alphaU = if (u == 0) 1 / kotlin.math.sqrt(2.0) else 1.0
            val alphaV = if (v == 0) 1 / kotlin.math.sqrt(2.0) else 1.0
            for (x in 0 until 8) {
                for (y in 0 until 8) {
                    // 求和阶段不再乘正交系数
                    sum += block[x * 8 + y] *
                            kotlin.math.cos((2 * x + 1) * u * PI / 16) *
                            kotlin.math.cos((2 * y + 1) * v * PI / 16)
                }
            }
            // 应用标准DCT缩放因子
            dctResult[u][v] = 0.25 * alphaU * alphaV * sum
        }
    }
    return dctResult
}

修正后的IDCT函数

匹配DCT的缩放规则，改用四舍五入处理精度：

private fun applyIDCT(dctCoefficients: Array<DoubleArray>): Array<Int> {
    val block = Array(64) { 0 }
    for (x in 0 until 8) {
        for (y in 0 until 8) {
            var sum = 0.0
            for (u in 0 until 8) {
                for (v in 0 until 8) {
                    val alphaU = if (u == 0) 1 / kotlin.math.sqrt(2.0) else 1.0
                    val alphaV = if (v == 0) 1 / kotlin.math.sqrt(2.0) else 1.0
                    sum += alphaU * alphaV * dctCoefficients[u][v] *
                            kotlin.math.cos((2 * x + 1) * u * PI / 16) *
                            kotlin.math.cos((2 * y + 1) * v * PI / 16)
                }
            }
            // 四舍五入代替截断，减少精度损失
            block[x * 8 + y] = (0.25 * sum).roundToInt()
        }
    }
    return block
}

3. 使用示例 #

fun main() {
    // 测试用64元素数组
    val originalBlock = Array(64) { it % 256 }
    // 执行DCT
    val dctCoeffs = applyDCT(originalBlock)
    // 执行IDCT还原
    val restoredBlock = applyIDCT(dctCoeffs)
    
    // 对比原始值与还原值
    for (i in originalBlock.indices) {
        println("原始值: ${originalBlock[i]}, 还原值: ${restoredBlock[i]}")
    }
}

修复后，还原值与原始值的误差会控制在±1范围内（浮点数计算的微小精度误差），基本实现无损还原。

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