Android 计算摄影实战：多帧合成、HDR+ 与夜景算法

第二章：多帧合成核心技术

2.1 帧对齐算法详解

2.1.1 金字塔光流对齐

class PyramidOpticalFlowAligner {
    fun alignFrames(reference: Mat, frames: List<Mat>): List<Mat> {
        val alignedFrames = mutableListOf<Mat>()
        frames.parallelStream().forEach { frame ->
            val aligned = alignSingleFrame(reference, frame)
            alignedFrames.add(aligned)
        }
        return alignedFrames
    }

    private fun alignSingleFrame(reference: Mat, frame: Mat): Mat {
        // 构建金字塔
        val refPyramid = buildGaussianPyramid(reference, 4)
        val framePyramid = buildGaussianPyramid(frame, 4)
        var flow = Mat()
        // 从顶层开始
        // 从顶层到底层逐层优化光流
        for (level in 3 downTo 0) {
            val refLevel = refPyramid[level]
            val frameLevel = framePyramid[level]
            // 如果 flow 非空，上采样到当前层
            if (flow.total() > 0) {
                flow = upscaleFlow(flow, 2.0)
            }
            // 在当前层计算光流
            flow = computeOpticalFlow(refLevel, frameLevel, flow)
        }
        // 应用光流对齐
        return warpWithFlow(frame, flow)
    }

    private fun computeOpticalFlow(
        ref: Mat,
        frame: Mat,
        initFlow: Mat? = null
    ): Mat {
        // Farneback 光流算法实现
        val flow = Mat()
        val pyrScale = 0.5
        val levels = 3
        val winsize = 15
        val iterations = 3
        val polyN = 5
        val polySigma = 1.2
        Video.calcOpticalFlowFarneback(
            ref, frame, flow, pyrScale, levels, winsize, iterations,
            polyN, polySigma,
            if (initFlow != null) OPTFLOW_USE_INITIAL_FLOW else 0
        )
        return flow
    }

    private fun buildGaussianPyramid(image: Mat, levels: Int): List<Mat> {
        val pyramid = mutableListOf<Mat>()
        pyramid.add(image.clone())
        for (i in 1 until levels) {
            val downscaled = Mat()
            Imgproc.pyrDown(pyramid[i - 1], downscaled)
            pyramid.add(downscaled)
        }
        return pyramid
    }
}

2.1.2 特征点对齐（针对大运动）

class FeatureBasedAligner {
    fun alignWithFeatures(reference: Mat, frame: Mat): Mat {
        // 检测特征点
        val refKeypoints = detectFeatures(reference)
        val frameKeypoints = detectFeatures(frame)
        // 特征描述子提取
        val refDescriptors = computeDescriptors(reference, refKeypoints)
        val frameDescriptors = computeDescriptors(frame, frameKeypoints)
        // 特征匹配
        val matches = matchFeatures(refDescriptors, frameDescriptors)
        // 使用 RANSAC 估计单应性矩阵
        val homography = estimateHomography(refKeypoints, frameKeypoints, matches)
        // 应用变换
        val aligned = Mat()
        Imgproc.warpPerspective(
            frame, aligned, homography, reference.size(),
            Imgproc.INTER_LINEAR + Imgproc.WARP_INVERSE_MAP
        )
        return aligned
    }

    private fun detectFeatures(image: Mat): MatOfKeyPoint {
        val detector = ORB.create(
            nfeatures = 5000,
            scaleFactor = 1.2f,
            nlevels = 8,
            edgeThreshold = 31
        )
        val keypoints = MatOfKeyPoint()
        detector.detect(image, keypoints)
        return keypoints
    }

    private fun estimateHomography(
        refPoints: MatOfKeyPoint,
        framePoints: MatOfKeyPoint,
        matches: MatOfDMatch
    ): Mat {
        val refPointsList = refPoints.toList()
        val framePointsList = framePoints.toList()
        val matchesList = matches.toList()
        val refMatched = mutableListOf<Point>()
        val frameMatched = mutableListOf<Point>()
        // 提取匹配点对
        matchesList.forEach { match ->
            refMatched.add(refPointsList[match.queryIdx].pt)
            frameMatched.add(framePointsList[match.trainIdx].pt)
        }
        val refMat = Converters.vector_Point2f_to_Mat(refMatched)
        val frameMat = Converters.vector_Point2f_to_Mat(frameMatched)
        // RANSAC 估计单应性矩阵
        return Calib3d.findHomography(
            frameMat, refMat, Calib3d.RANSAC, 3.0
        )
    }
}

2.2 多帧降噪算法

class MultiFrameDenoiser {
    data class DenoiseResult(
        val denoisedImage: Mat,
        val noiseMap: Mat,
        val confidenceMap: Mat
    )

    fun denoiseBurst(frames: List<Mat>, alignmentMaps: List<Mat>): DenoiseResult {
        // 1. 运动自适应权重计算
        val weights = computeMotionWeights(frames, alignmentMaps)
        // 2. 时域递归滤波
        val tempFiltered = temporalRecursiveFilter(frames, weights)
        // 3. 空域非局部均值降噪
        val spatialDenoised = nonLocalMeans(tempFiltered)
        // 4. 细节增强与噪声抑制平衡
        val finalResult = balanceDetailNoise(spatialDenoised, weights)
        return finalResult
    }

    private fun computeMotionWeights(
        frames: List<Mat>,
        alignmentMaps: List<Mat>
    ): List<Mat> {
        val weights = mutableListOf<Mat>()
        frames.forEachIndexed { index, frame ->
            val weightMap = Mat(frame.size(), CvType.CV_32F)
            weightMap.setTo(Scalar(1.0))
            if (index > 0) {
                // 计算与参考帧的运动差异
                val motion = alignmentMaps[index]
                val motionMagnitude = computeMotionMagnitude(motion)
                // 根据运动幅度调整权重
                Core.divide(
                    Scalar(1.0),
                    Scalar(1.0 + motionMagnitude * 10.0),
                    weightMap
                )
                // 考虑像素级对齐误差
                val alignmentError = computeAlignmentError(frames[0], frame, motion)
                Core.multiply(weightMap, Scalar(1.0) - alignmentError, weightMap)
            }
            weights.add(weightMap)
        }
        return weights
    }

    private fun temporalRecursiveFilter(
        frames: List<Mat>,
        weights: List<Mat>
    ): Mat {
        val result = Mat(frames[0].size(), frames[0].type())
        result.setTo(Scalar(0.0))
        var totalWeight = 0.0
        frames.forEachIndexed { index, frame ->
            val floatFrame = Mat()
            frame.convertTo(floatFrame, CvType.CV_32F)
            val weightedFrame = Mat()
            Core.multiply(floatFrame, weights[index], weightedFrame)
            Core.add(result, weightedFrame, result)
            totalWeight += Core.sum(weights[index]).val[0]
        }
        Core.divide(result, Scalar(totalWeight / frames.size), result)
        return result
    }

    private fun nonLocalMeans(image: Mat): Mat {
        val denoised = Mat()
        // 参数调整
        val h = 10.0 // 降噪强度
        val templateWindowSize = 7
        val searchWindowSize = 21
        Imgproc.fastNlMeansDenoising(
            image, denoised, h.toFloat(),
            templateWindowSize, searchWindowSize
        )
        return denoised
    }
}

第三章：HDR+ 算法实现

3.1 多曝光融合算法

class HDRPlusProcessor {
    data class HDRConfig(
        val numFrames: Int = 15,
        val exposureBias: DoubleArray = doubleArrayOf(-4.0, -2.0, 0.0, 2.0, 4.0),
        val mergeMethod: MergeMethod = MergeMethod.WEIGHTED_AVERAGE,
        val toneMapping: ToneMappingMethod = ToneMappingMethod.REINHARD
    )

    enum class MergeMethod {
        WEIGHTED_AVERAGE, // 加权平均
        DEBEVEC, // Debevec 方法
        ROBERTSON, // Robertson 方法
        MERTENS // Mertens 融合
    }

    fun processHDRPlus(
        rawBurst: List<RawImage>,
        config: HDRConfig = HDRConfig()
    ): HDRResult {
        // 1. 预处理：去马赛克、黑电平校正
        val processed = preprocessRawBurst(rawBurst)
        // 2. 曝光对齐
        val aligned = alignExposures(processed)
        // 3. 相机响应函数估计
        val crf = estimateCRF(aligned)
        // 4. 辐照度图重建
        val irradiance = reconstructIrradiance(aligned, crf)
        // 5. 色调映射
        val toneMapped = applyToneMapping(irradiance, config.toneMapping)
        // 6. 局部对比度增强
        val enhanced = enhanceLocalContrast(toneMapped)
        return HDRResult(
            irradianceMap = irradiance,
            toneMapped = toneMapped,
            enhanced = enhanced,
            crf = crf
        )
    }

    private fun reconstructIrradiance(
        exposures: List<ExposureFrame>,
        crf: CameraResponseFunction
    ): Mat {
        val irradiance = Mat(exposures[0].image.size(), CvType.CV_32FC3)
        irradiance.setTo(Scalar(0.0))
        val weightSum = Mat(irradiance.size(), CvType.CV_32F)
        weightSum.setTo(Scalar(0.0))
        exposures.forEach { frame ->
            // 计算每个像素的权重（三角权重函数）
            val weightMap = computeWeightMap(frame.image)
            // 应用响应函数反变换
            val linearized = applyInverseCRF(frame.image, crf, frame.exposureTime)
            // 加权累加
            val weighted = Mat()
            Core.multiply(linearized, weightMap, weighted)
            Core.add(irradiance, weighted, irradiance)
            Core.add(weightSum, weightMap, weightSum)
        }
        // 归一化
        Core.divide(irradiance, weightSum, irradiance)
        return irradiance
    }

    private fun computeWeightMap(image: Mat): Mat {
        val weightMap = Mat(image.size(), CvType.CV_32F)
        // 使用三角权重函数
        // w(z) = z for z ≤ 0.5, w(z) = 1 - z for z > 0.5
        val normalized = Mat()
        image.convertTo(normalized, CvType.CV_32F, 1.0 / 255.0)
        val mask1 = Mat()
        Core.compare(normalized, Scalar(0.5), mask1, Core.CMP_LE)
        val mask2 = Mat()
        Core.compare(normalized, Scalar(0.5), mask2, Core.CMP_GT)
        val weight1 = Mat()
        normalized.copyTo(weight1, mask1)
        val weight2 = Mat()
        Core.subtract(Scalar(1.0), normalized, weight2)
        weight2.copyTo(weight1, mask2)
        return weight1
    }
}

3.2 色调映射算法

class ToneMapper {
    fun reinhardToneMapping(hdrImage: Mat, key: Float = 0.18f): Mat {
        // 1. 转换到 Log 域
        val logImage = Mat()
        Core.add(hdrImage, Scalar(1e-6), logImage) // 避免 log(0)
        Core.log(logImage, logImage)
        // 2. 计算平均亮度
        val luma = extractLuminance(hdrImage)
        val avgLuminance = computeLogAverage(luma)
        // 3. 缩放亮度
        val scaled = Mat()
        Core.divide(
            logImage,
            Scalar(Math.log(avgLuminance + 1e-6)),
            scaled
        )
        Core.multiply(scaled, Scalar(Math.log(key)), scaled)
        // 4. 应用 Reinhard 算子
        val toneMapped = Mat()
        Core.exp(scaled, toneMapped)
        // L_d = L * (1 + L / L_white²) / (1 + L)
        val lWhite = 1.5 * key // 白点亮度
        val numerator = Mat()
        Core.multiply(
            toneMapped,
            Scalar(1.0) + toneMapped / (lWhite * lWhite),
            numerator
        )
        Core.divide(numerator, Scalar(1.0) + toneMapped, toneMapped)
        return toneMapped
    }

    fun durandToneMapping(hdrImage: Mat): Mat {
        // 基于双边滤波的色调映射
        val luma = extractLuminance(hdrImage)
        // 1. 计算 base 层（大尺度信息）
        val base = bilateralFilter(luma, 20.0, 50.0)
        // 2. 计算 detail 层
        val detail = Mat()
        Core.divide(luma, base + 1e-6, detail)
        // 3. 压缩 base 层
        val logBase = Mat()
        Core.log(base, logBase)
        val maxLog = Core.minMaxLoc(logBase).maxVal
        val minLog = Core.minMaxLoc(logBase).minVal
        val compressedBase = Mat()
        Core.multiply(
            logBase,
            Scalar(0.1 / (maxLog - minLog)),
            compressedBase
        )
        // 4. 重建
        val compressedLuma = Mat()
        Core.exp(compressedBase, compressedBase)
        Core.multiply(compressedBase, detail, compressedLuma)
        // 5. 恢复颜色
        return restoreColor(hdrImage, luma, compressedLuma)
    }

    fun adaptiveLocalToneMapping(hdrImage: Mat): Mat {
        // 基于局部窗口的自适应色调映射
        val result = Mat(hdrImage.size(), hdrImage.type())
        val blockSize = 32
        val overlap = 8
        // 分块处理
        for (y in 0 until hdrImage.rows() step blockSize - overlap) {
            for (x in 0 until hdrImage.cols() step blockSize - overlap) {
                val yEnd = min(y + blockSize, hdrImage.rows())
                val xEnd = min(x + blockSize, hdrImage.cols())
                val block = hdrImage.rowRange(y, yEnd).colRange(x, xEnd)
                // 计算局部统计
                val mean = Core.mean(block)
                val stddev = Mat()
                Core.meanStdDev(block, Mat(), stddev)
                // 自适应参数
                val localKey = (mean.val[0] / 255.0).toFloat()
                val contrast = stddev.get(0, 0)[0] / 100.0
                // 应用局部色调映射
                val toneMappedBlock = reinhardToneMapping(block, localKey)
                // 对比度增强
                Core.multiply(
                    toneMappedBlock,
                    Scalar(1.0 + contrast * 0.5),
                    toneMappedBlock
                )
                // 混合边界
                blendBlock(result, toneMappedBlock, x, y, xEnd - x, yEnd - y, overlap)
            }
        }
        return result
    }
}

第四章：夜景模式算法实现

4.1 低光图像增强

class NightModeProcessor {
    fun processNightShot(
        burst: List<Mat>,
        metadata: List<CameraMetadata>
    ): NightModeResult {
        // 1. 时域降噪（多帧）
        val denoised = temporalDenoise(burst)
        // 2. 暗光增强
        val enhanced = enhanceLowLight(denoised)
        // 3. 色彩恢复
        val colorCorrected = restoreColor(enhanced)
        // 4. 细节增强
        val detailEnhanced = enhanceDetails(colorCorrected)
        // 5. 噪声抑制
        val final = suppressNoise(detailEnhanced)
        return NightModeResult(
            denoised = denoised,
            enhanced = enhanced,
            final = final,
            noiseProfile = estimateNoiseProfile(burst)
        )
    }

    private fun enhanceLowLight(image: Mat): Mat {
        // 基于 Retinex 理论的低光增强
        val result = Mat(image.size(), image.type())
        // 多尺度 Retinex
        val scales = listOf(15, 80, 250)
        val weight = 1.0 / scales.size
        scales.forEach { scale ->
            val blurred = Mat()
            Imgproc.GaussianBlur(image, blurred, Size(0.0, 0.0), scale.toDouble())
            val logImage = Mat()
            Core.log(image + Scalar(1.0), logImage)
            val logBlurred = Mat()
            Core.log(blurred + Scalar(1.0), logBlurred)
            val singleScale = Mat()
            Core.subtract(logImage, logBlurred, singleScale)
            Core.addWeighted(result, 1.0, singleScale, weight, 0.0, result)
        }
        // 对比度拉伸
        val normalized = normalizeImage(result)
        return normalized
    }

    private fun enhanceDetails(image: Mat): Mat {
        // 基于引导滤波的细节增强
        val guide = extractLuminance(image)
        val base = Mat()
        val detail = Mat()
        // 引导滤波得到 base 层
        guidedFilter(guide, guide, base, 8, 0.01)
        // 计算 detail 层
        Core.divide(image, base + Scalar(1e-6), detail)
        // 增强 detail 层
        val enhancedDetail = Mat()
        Core.pow(detail, 1.2, enhancedDetail)
        // 重建图像
        val result = Mat()
        Core.multiply(base, enhancedDetail, result)
        return result
    }
}

4.2 手持夜景稳定算法

class HandheldNightProcessor {
    fun processHandheldNight(
        burst: List<Mat>,
        gyroData: List<GyroSample>
    ): Mat {
        // 1. 运动轨迹估计
        val trajectory = estimateMotionTrajectory(burst, gyroData)
        // 2. 运动补偿
        val stabilized = motionCompensation(burst, trajectory)
        // 3. 自适应曝光融合
        val exposureWeights = computeExposureWeights(stabilized)
        // 4. 噪声自适应融合
        val noiseWeights = computeNoiseWeights(stabilized)
        // 5. 多帧融合
        val fused = adaptiveFusion(stabilized, exposureWeights, noiseWeights)
        // 6. 运动模糊检测与修复
        val deblurred = detectAndRepairMotionBlur(fused, trajectory)
        return deblurred
    }

    private fun estimateMotionTrajectory(
        frames: List<Mat>,
        gyroData: List<GyroSample>
    ): MotionTrajectory {
        val trajectory = MotionTrajectory()
        // 结合视觉和 IMU 数据
        frames.forEachIndexed { index, frame ->
            if (index > 0) {
                // 视觉光流
                val opticalFlow = computeOpticalFlow(frames[index - 1], frame)
                // IMU 积分
                val imuMotion = integrateGyro(gyroData, index)
                // 传感器融合
                val fusedMotion = fuseMotionEstimation(opticalFlow, imuMotion)
                trajectory.add(fusedMotion)
            }
        }
        return trajectory
    }

    private fun adaptiveFusion(
        frames: List<Mat>,
        exposureWeights: List<Mat>,
        noiseWeights: List<Mat>
    ): Mat {
        val result = Mat(frames[0].size(), frames[0].type())
        result.setTo(Scalar(0.0))
        var totalWeight = Mat(result.size(), CvType.CV_32F)
        totalWeight.setTo(Scalar(0.0))
        frames.forEachIndexed { index, frame ->
            // 组合权重：曝光质量 × 噪声水平 × 对齐置信度
            val combinedWeight = Mat()
            Core.multiply(exposureWeights[index], noiseWeights[index], combinedWeight)
            val weightedFrame = Mat()
            frame.convertTo(weightedFrame, CvType.CV_32F)
            Core.multiply(weightedFrame, combinedWeight, weightedFrame)
            Core.add(result, weightedFrame, result)
            Core.add(totalWeight, combinedWeight, totalWeight)
        }
        Core.divide(result, totalWeight + Scalar(1e-6), result)
        result.convertTo(result, frames[0].type())
        return result
    }
}

第五章：深度神经网络增强

5.1 基于深度学习的多帧融合

class DeepFusionProcessor {
    private val tfLite: Interpreter

    init {
        // 加载 TFLite 模型
        val model = loadModelFile("deep_fusion.tflite")
        val options = Interpreter.Options()
        options.setUseNNAPI(true)
        tfLite = Interpreter(model, options)
    }

    fun deepFusion(
        burst: List<Mat>,
        metadata: List<CameraMetadata>
    ): Mat {
        // 1. 准备输入张量
        val inputs = prepareInputTensors(burst, metadata)
        // 2. 运行推理
        val outputs = HashMap<Int, Any>()
        val outputTensor = TensorBuffer.createFixedSize(
            intArrayOf(1, 1080, 1920, 3),
            DataType.FLOAT32
        )
        outputs[0] = outputTensor.buffer
        tfLite.runForMultipleInputsOutputs(inputs, outputs)
        // 3. 后处理
        val result = postProcessOutput(outputTensor)
        return result
    }

    private fun prepareInputTensors(
        burst: List<Mat>,
        metadata: List<CameraMetadata>
    ): Array<Any> {
        // 将 burst 和 metadata 转换为模型输入格式
        val inputs = mutableListOf<Any>()
        // 图像数据
        val imageTensor = TensorBuffer.createFixedSize(
            intArrayOf(burst.size, 1080, 1920, 3),
            DataType.FLOAT32
        )
        val floatValues = FloatArray(burst.size * 1080 * 1920 * 3)
        var idx = 0
        burst.forEach { frame ->
            val floatFrame = Mat()
            frame.convertTo(floatFrame, CvType.CV_32F, 1.0 / 255.0)
            for (c in 0 until 3) {
                for (y in 0 until 1080) {
                    for (x in 0 until 1920) {
                        floatValues[idx++] = floatFrame.get(y, x)[c].toFloat()
                    }
                }
            }
        }
        imageTensor.loadArray(floatValues)
        inputs.add(imageTensor.buffer)
        // 元数据（ISO、曝光时间、白平衡等）
        val metaTensor = TensorBuffer.createFixedSize(
            intArrayOf(burst.size, 10),
            DataType.FLOAT32
        )
        val metaValues = FloatArray(burst.size * 10)
        metadata.forEachIndexed { index, meta ->
            metaValues[index * 10] = meta.iso.toFloat()
            metaValues[index * 10 + 1] = meta.exposureTime.toFloat()
            // ... 其他元数据
        }
        metaTensor.loadArray(metaValues)
        inputs.add(metaTensor.buffer)
        return inputs.toTypedArray()
    }
}

5.2 语义感知的局部增强

class SemanticAwareEnhancer {
    fun semanticEnhancement(image: Mat, segmentation: Mat): Mat {
        val result = image.clone()
        // 获取语义类别
        val skyMask = extractMask(segmentation, SemanticClass.SKY)
        val faceMask = extractMask(segmentation, SemanticClass.FACE)
        val textMask = extractMask(segmentation, SemanticClass.TEXT)
        // 天空区域：增强对比度，保留细节
        if (skyMask.total() > 0) {
            val skyRegion = Mat()
            image.copyTo(skyRegion, skyMask)
            val enhancedSky = enhanceSky(skyRegion)
            enhancedSky.copyTo(result, skyMask)
        }
        // 人脸区域：皮肤平滑，保持自然
        if (faceMask.total() > 0) {
            val faceRegion = Mat()
            image.copyTo(faceRegion, faceMask)
            val enhancedFace = enhanceFace(faceRegion)
            enhancedFace.copyTo(result, faceMask)
        }
        // 文本区域：锐化，提高可读性
        if (textMask.total() > 0) {
            val textRegion = Mat()
            image.copyTo(textRegion, textMask)
            val enhancedText = enhanceText(textRegion)
            enhancedText.copyTo(result, textMask)
        }
        return result
    }

    private fun enhanceSky(skyImage: Mat): Mat {
        // 天空特定增强
        val enhanced = skyImage.clone()
        // 增强蓝色通道
        val channels = mutableListOf<Mat>()
        Core.split(enhanced, channels)
        val blueChannel = channels[0]
        Core.multiply(blueChannel, Scalar(1.2), blueChannel)
        // 增加对比度
        Core.merge(channels, enhanced)
        Core.normalize(enhanced, enhanced, 0.0, 255.0, Core.NORM_MINMAX)
        return enhanced
    }

    private fun enhanceFace(faceImage: Mat): Mat {
        // 人脸特定增强
        val enhanced = faceImage.clone()
        // 皮肤检测
        val skinMask = detectSkin(faceImage)
        if (skinMask.total() > 0) {
            // 皮肤平滑
            val skinRegion = Mat()
            faceImage.copyTo(skinRegion, skinMask)
            val smoothed = bilateralFilter(skinRegion, 5.0, 25.0)
            smoothed.copyTo(enhanced, skinMask)
            // 嘴唇增强
            val lipMask = detectLips(faceImage)
            if (lipMask.total() > 0) {
                val lips = Mat()
                faceImage.copyTo(lips, lipMask)
                val enhancedLips = enhanceLips(lips)
                enhancedLips.copyTo(enhanced, lipMask)
            }
        }
        return enhanced
    }
}

第六章：Android 平台优化实现

6.1 内存高效的多帧处理

class MemoryEfficientProcessor {
    fun processLargeBurst(
        burst: List<Image>,
        strategy: ProcessingStrategy = ProcessingStrategy.TILE_BASED
    ): Bitmap {
        return when (strategy) {
            ProcessingStrategy.TILE_BASED -> processByTiles(burst)
            ProcessingStrategy.PYRAMID -> processByPyramid(burst)
            ProcessingStrategy.STREAMING -> processStreaming(burst)
        }
    }

    private fun processByTiles(burst: List<Image>): Bitmap {
        val tileSize = 256
        val overlap = 32
        val firstImage = burst[0]
        val result = Bitmap.createBitmap(
            firstImage.width,
            firstImage.height,
            Bitmap.Config.ARGB_8888
        )
        val canvas = Canvas(result)
        // 分块处理
        for (y in 0 until firstImage.height step tileSize - overlap) {
            for (x in 0 until firstImage.width step tileSize - overlap) {
                val tileRect = Rect(
                    x,
                    y,
                    min(x + tileSize, firstImage.width),
                    min(y + tileSize, firstImage.height)
                )
                // 提取所有图像的该区域
                val tiles = burst.map { extractTile(it, tileRect) }
                // 处理该区域
                val processedTile = processTile(tiles)
                // 混合到结果中
                blendTile(canvas, processedTile, tileRect, overlap)
                // 及时释放内存
                tiles.forEach { it.recycle() }
            }
        }
        return result
    }

    private fun processByPyramid(burst: List<Image>): Bitmap {
        // 构建金字塔，在低分辨率上处理，然后上采样
        val scaleFactor = 0.25
        val smallBurst = burst.map {
            Bitmap.createScaledBitmap(
                it,
                (it.width * scaleFactor).toInt(),
                (it.height * scaleFactor).toInt(),
                true
            )
        }
        // 在小图上处理
        val smallResult = processFull(smallBurst)
        // 引导上采样
        return guidedUpsample(smallResult, burst[0])
    }
}

6.2 GPU 加速实现

class GPUAcceleratedProcessor {
    private val glThread: HandlerThread
    private val glHandler: Handler
    private var eglCore: EGLCore? = null

    init {
        glThread = HandlerThread("GPUProcessor")
        glThread.start()
        glHandler = Handler(glThread.looper)
    }

    fun processOnGPU(
        burst: List<Bitmap>,
        callback: (Bitmap) -> Unit
    ) {
        glHandler.post {
            // 初始化 EGL 环境
            eglCore = EGLCore(null, EGLCore.FLAG_RECORDABLE)
            val eglSurface = eglCore?.createOffscreenSurface(
                burst[0].width,
                burst[0].height
            )
            eglCore?.makeCurrent(eglSurface)
            // 上传纹理到 GPU
            val textures = burst.map { uploadToTexture(it) }
            // GPU 处理
            val resultTexture = processTexturesOnGPU(textures)
            // 下载结果
            val resultBitmap = downloadFromTexture(resultTexture)
            // 清理
            deleteTextures(textures + resultTexture)
            eglCore?.releaseSurface(eglSurface)
            eglCore?.release()
            // 回调到主线程
            Handler(Looper.getMainLooper()).post { callback(resultBitmap) }
        }
    }

    private fun processTexturesOnGPU(textures: List<Int>): Int {
        val program = createComputeProgram("""
            #version 310 es
            layout(local_size_x = 16, local_size_y = 16) in;
            layout(rgba32f, binding = 0) readonly uniform image2D inputTextures[8];
            layout(rgba32f, binding = 1) writeonly uniform image2D outputTexture;
            void main(){
                ivec2 pos = ivec2(gl_GlobalInvocationID.xy);
                vec4 sum = vec4(0.0);
                // 多帧平均
                for(int i = 0; i < 8; i++){
                    sum += imageLoad(inputTextures[i], pos);
                }
                vec4 result = sum / 8.0;
                // 应用色调映射
                result = result / (result + vec4(1.0));
                imageStore(outputTexture, pos, result);
            }
        """)
        GLES31.glUseProgram(program)
        // 绑定输入纹理
        textures.forEachIndexed { index, texture ->
            GLES31.glBindImageTexture(
                index, texture, 0, false, 0,
                GLES31.GL_READ_ONLY, GLES31.GL_RGBA32F
            )
        }
        // 创建输出纹理
        val outputTexture = createOutputTexture()
        GLES31.glBindImageTexture(
            textures.size, outputTexture, 0, false, 0,
            GLES31.GL_WRITE_ONLY, GLES31.GL_RGBA32F
        )
        // 调度计算
        val groupX = ceil(textures[0].width / 16.0).toInt()
        val groupY = ceil(textures[0].height / 16.0).toInt()
        GLES31.glDispatchCompute(groupX, groupY, 1)
        // 内存屏障
        GLES31.glMemoryBarrier(GLES31.GL_SHADER_IMAGE_ACCESS_BARRIER_BIT)
        return outputTexture
    }
}

第七章：质量评估与调优

7.1 客观质量评估

class QualityAssessor {
    data class QualityMetrics(
        val psnr: Double, // 峰值信噪比
        val ssim: Double, // 结构相似性
        val noiseLevel: Double, // 噪声水平
        val dynamicRange: Double, // 动态范围
        val colorAccuracy: Double // 色彩准确度
    )

    fun assessHDRQuality(reference: Mat, processed: Mat): QualityMetrics {
        return QualityMetrics(
            psnr = calculatePSNR(reference, processed),
            ssim = calculateSSIM(reference, processed),
            noiseLevel = estimateNoiseLevel(processed),
            dynamicRange = calculateDynamicRange(processed),
            colorAccuracy = assessColorAccuracy(reference, processed)
        )
    }

    private fun calculatePSNR(original: Mat, processed: Mat): Double {
        val mse = Mat()
        Core.subtract(original, processed, mse)
        Core.multiply(mse, mse, mse)
        val mseValue = Core.mean(mse).val[0]
        if (mseValue == 0.0) return Double.POSITIVE_INFINITY
        val maxPixel = 255.0
        return 20.0 * Math.log10(maxPixel / Math.sqrt(mseValue))
    }

    private fun calculateSSIM(original: Mat, processed: Mat): Double {
        val c1 = 6.5025
        val c2 = 58.5225
        val mu1 = Mat()
        val mu2 = Mat()
        Imgproc.GaussianBlur(original, mu1, Size(11, 11), 1.5)
        Imgproc.GaussianBlur(processed, mu2, Size(11, 11), 1.5)
        val mu1Sq = Mat()
        val mu2Sq = Mat()
        val mu1Mu2 = Mat()
        Core.multiply(mu1, mu1, mu1Sq)
        Core.multiply(mu2, mu2, mu2Sq)
        Core.multiply(mu1, mu2, mu1Mu2)
        val sigma1Sq = Mat()
        val sigma2Sq = Mat()
        val sigma12 = Mat()
        val img1Sq = Mat()
        val img2Sq = Mat()
        val img1Img2 = Mat()
        Core.multiply(original, original, img1Sq)
        Core.multiply(processed, processed, img2Sq)
        Core.multiply(original, processed, img1Img2)
        Imgproc.GaussianBlur(img1Sq, sigma1Sq, Size(11, 11), 1.5)
        Core.subtract(sigma1Sq, mu1Sq, sigma1Sq)
        Imgproc.GaussianBlur(img2Sq, sigma2Sq, Size(11, 11), 1.5)
        Core.subtract(sigma2Sq, mu2Sq, sigma2Sq)
        Imgproc.GaussianBlur(img1Img2, sigma12, Size(11, 11), 1.5)
        Core.subtract(sigma12, mu1Mu2, sigma12)
        val numerator1 = Mat()
        val numerator2 = Mat()
        val denominator1 = Mat()
        val denominator2 = Mat()
        Core.multiply(mu1Mu2, Scalar(2.0), numerator1)
        Core.add(numerator1, Scalar(c1), numerator1)
        Core.multiply(sigma12, Scalar(2.0), numerator2)
        Core.add(numerator2, Scalar(c2), numerator2)
        Core.add(mu1Sq, mu2Sq, denominator1)
        Core.add(denominator1, Scalar(c1), denominator1)
        Core.add(sigma1Sq, sigma2Sq, denominator2)
        Core.add(denominator2, Scalar(c2), denominator2)
        val ssimMap = Mat()
        Core.multiply(numerator1, numerator2, ssimMap)
        Core.divide(ssimMap, denominator1, ssimMap)
        Core.divide(ssimMap, denominator2, ssimMap)
        return Core.mean(ssimMap).val[0]
    }
}

7.2 参数自动调优

class AutoTuner {
    fun tuneParameters(
        burst: List<Mat>,
        targetMetrics: QualityMetrics
    ): ProcessingParameters {
        // 使用贝叶斯优化搜索最佳参数
        val optimizer = BayesianOptimizer()
        val bestParams = optimizer.optimize {
            params ->
            // 使用当前参数处理图像
            val processed = processWithParameters(burst, params)
            // 评估质量
            val metrics = assessQuality(processed)
            // 计算损失
            val loss = calculateLoss(metrics, targetMetrics)
            loss
        }
        return bestParams
    }

    data class ProcessingParameters(
        val numFramesToMerge: Int,
        val alignmentMethod: AlignmentMethod,
        val denoiseStrength: Double,
        val toneMappingStrength: Double,
        val detailEnhancement: Double,
        val colorSaturation: Double
    )

    class BayesianOptimizer {
        fun optimize(objective: (ProcessingParameters) -> Double): ProcessingParameters {
            // 高斯过程回归寻找最优参数
            val gp = GaussianProcess()
            var bestParams: ProcessingParameters? = null
            var bestScore = Double.MAX_VALUE
            // 迭代优化
            repeat(50) { iteration ->
                // 采集样本
                val samples = sampleParameterSpace()
                val scores = samples.map { objective(it) }
                // 更新高斯过程
                gp.update(samples, scores)
                // 获取下一个采样点（期望改进最大）
                val nextSample = gp.suggestNextSample()
                val nextScore = objective(nextSample)
                if (nextScore < bestScore) {
                    bestScore = nextScore
                    bestParams = nextSample
                }
            }
            return bestParams!!
        }
    }
}

第八章：完整实现示例

8.1 完整的 HDR+ 流水线

class CompleteHDRPlusPipeline {
    fun executeFullPipeline(cameraImages: List<Image>): Bitmap {
        val startTime = System.currentTimeMillis()
        // 阶段 1: 数据准备
        logger.info("阶段 1: 数据准备")
        val rawImages = cameraImages.map { convertToRawImage(it) }
        val metadata = cameraImages.map { extractMetadata(it) }
        // 阶段 2: 预处理
        logger.info("阶段 2: 预处理")
        val preprocessed = preprocessRawImages(rawImages)
        // 阶段 3: 对齐
        logger.info("阶段 3: 帧对齐")
        val alignmentData = alignFrames(preprocessed)
        // 阶段 4: 融合
        logger.info("阶段 4: 多帧融合")
        val fused = fuseFrames(preprocessed, alignmentData)
        // 阶段 5: 色调映射
        logger.info("阶段 5: 色调映射")
        val toneMapped = applyToneMapping(fused)
        // 阶段 6: 后处理
        logger.info("阶段 6: 后处理")
        val enhanced = postProcess(toneMapped)
        // 阶段 7: 输出
        logger.info("阶段 7: 输出准备")
        val result = prepareOutput(enhanced)
        val endTime = System.currentTimeMillis()
        logger.info("总处理时间：${endTime - startTime}ms")
        return result
    }

    private fun fuseFrames(
        frames: List<Mat>,
        alignmentData: AlignmentData
    ): Mat {
        // 加权融合考虑因素:
        // 1. 曝光正确性
        // 2. 运动模糊程度
        // 3. 噪声水平
        // 4. 对齐质量
        val weights = computeFusionWeights(frames, alignmentData)
        val fused = weightedMerge(frames, weights)
        return fused
    }

    private fun computeFusionWeights(
        frames: List<Mat>,
        alignmentData: AlignmentData
    ): List<Mat> {
        val weights = mutableListOf<Mat>()
        frames.forEachIndexed { index, frame ->
            val weightMap = Mat(frame.size(), CvType.CV_32F)
            weightMap.setTo(Scalar(1.0))
            // 考虑曝光质量
            val exposureWeight = computeExposureQuality(frame)
            Core.multiply(weightMap, exposureWeight, weightMap)
            // 考虑运动模糊
            val motionBlur = estimateMotionBlur(frame, alignmentData.getMotion(index))
            val motionWeight = Scalar(1.0) - motionBlur
            Core.multiply(weightMap, motionWeight, weightMap)
            // 考虑噪声水平
            val noiseLevel = estimateNoiseLevel(frame)
            val noiseWeight = Scalar(1.0) / (Scalar(1.0) + noiseLevel * 10.0)
            Core.multiply(weightMap, noiseWeight, weightMap)
            // 考虑对齐置信度
            val alignmentConfidence = alignmentData.getConfidence(index)
            Core.multiply(weightMap, alignmentConfidence, weightMap)
            weights.add(weightMap)
        }
        return weights
    }
}

8.2 性能监控与调优

class PerformanceMonitor {
    private val performanceStats = mutableMapOf<String, PerformanceMetric>()

    fun monitorPipeline(pipeline: () -> Bitmap): PipelinePerformance {
        val cpuBefore = getCpuUsage()
        val memoryBefore = getMemoryUsage()
        val batteryBefore = getBatteryLevel()
        val startTime = System.nanoTime()
        val result = pipeline()
        val endTime = System.nanoTime()
        val cpuAfter = getCpuUsage()
        val memoryAfter = getMemoryUsage()
        val batteryAfter = getBatteryLevel()
        return PipelinePerformance(
            processingTime = (endTime - startTime) / 1_000_000.0,
            cpuUsage = cpuAfter - cpuBefore,
            memoryIncrease = memoryAfter - memoryBefore,
            batteryConsumption = batteryBefore - batteryAfter,
            frameRate = 1000.0 / ((endTime - startTime) / 1_000_000.0)
        )
    }

    data class PipelinePerformance(
        val processingTime: Double, // 毫秒
        val cpuUsage: Double, // 百分比
        val memoryIncrease: Long, // 字节
        val batteryConsumption: Double, // 毫安时
        val frameRate: Double // FPS
    )

    fun generatePerformanceReport(): String {
        return buildString {
            appendln("=== 计算摄影性能报告 ===")
            appendln("平均处理时间：${performanceStats["processingTime"]?.average ?: 0}ms")
            appendln("峰值内存使用：${performanceStats["memory"]?.max ?: 0}MB")
            appendln("平均 CPU 使用率：${performanceStats["cpu"]?.average ?: 0}%")
            appendln("平均帧率：${performanceStats["frameRate"]?.average ?: 0}FPS")
            appendln("电池消耗：${performanceStats["battery"]?.total ?: 0}mAh")
            // 瓶颈分析
            val bottlenecks = analyzeBottlenecks()
            appendln("\n=== 性能瓶颈分析 ===")
            bottlenecks.forEach { appendln("- $it") }
            // 优化建议
            val suggestions = generateSuggestions()
            appendln("\n=== 优化建议 ===")
            suggestions.forEach { appendln("- $it") }
        }
    }
}

第九章：未来发展与趋势

9.1 新兴技术方向

1. 神经渲染
   • 使用 GAN 生成缺失细节
   • 神经辐射场（NeRF）用于视角合成
   • 扩散模型用于图像增强
2. 传感器融合
   • 多光谱传感器数据融合
   • ToF 深度信息与 RGB 融合
   • 事件相机动态范围扩展
3. 实时计算摄影
   • 4K 60fps 实时 HDR 视频
   • 实时神经风格迁移
   • 实时语义分割与增强

9.2 硬件加速趋势

class NextGenHardwareAccelerator {
    // DPU（数字信号处理器）加速
    fun dpuAcceleratedFusion(burst: List<Mat>): Mat {
        // 使用专用硬件单元
    }

    // NPU（神经网络处理器）加速
    fun npuAcceleratedEnhancement(image: Mat): Mat {
        // 使用神经网络加速器
    }

    // ISP+（增强图像信号处理器）
    fun ispPlusProcessing(rawData: ByteArray): Bitmap {
        // 片上计算摄影
    }
}

总结与实践建议

通过本文的深度解析，我们实现了完整的计算摄影流水线。关键实践建议：

🎯 核心要点：

1. 对齐质量决定上限：投资于高质量的运动估计和补偿算法
2. 噪声模型是关键：准确的噪声估计是多帧降噪的基础
3. 局部自适应处理：全局参数无法应对复杂场景
4. 计算资源平衡：在质量、速度和功耗间找到平衡点

🚀 部署建议：

1. 渐进式增强：根据设备能力动态调整算法复杂度
2. 预热优化：缓存常用参数和模型
3. 异步处理：利用多核 CPU 和异构计算
4. 内存复用：避免不必要的内存分配和拷贝

📊 质量保证：

1. 建立测试集：涵盖各种光照和运动条件
2. 客观评估：使用 PSNR、SSIM 等指标量化质量
3. 主观评估：组织用户测试获取真实反馈
4. 回归测试：确保优化不降低现有质量

计算摄影正在快速发展，从多帧合成到深度学习增强，技术栈不断演进。通过本文的实现框架，您可以构建出媲美顶级手机厂商的计算摄影能力，为用户提供卓越的移动摄影体验。