iOS 3D视差效果实战：CoreML多模型融合与Metal视差渲染

1. 项目概述与核心思路

最近在折腾一个挺有意思的 iOS 项目，叫 3Dify。简单来说，它能让你的普通照片“活”起来，产生一种类似 3D 视差的效果，就像你在一些高端手机上看到的动态壁纸那样，随着手机角度的轻微移动，照片里的景物会有前后层次的错动感。这玩意儿听起来有点黑科技，但拆解开来，核心思路其实很清晰：先给照片“算”出一张深度图，再用这张图去驱动一个视差渲染引擎。

深度图，你可以把它理解成一张黑白照片，越白的地方代表离你越近，越黑的地方代表离你越远。有了这张“远近地图”，我们就能知道照片里每个像素的深度信息。3Dify 的聪明之处在于，它针对不同硬件设备，采用了两种截然不同的方案来获取这张深度图。对于配备了多摄像头阵列（比如 iPhone 的人像模式）的设备，系统本身就提供了高质量的视差图，直接拿来用就行，这是最理想的状况。但对于那些只有单摄像头的“老”设备（比如经典的 iPhone SE 第一代），就得靠算法来“猜”深度了，这也是这个项目技术含量最高的部分。

我之所以对这个项目感兴趣，是因为它完整地串联了 iOS 开发中几个非常核心且强大的技术栈：CoreML用于机器学习的深度预测，Metal用于高性能的图形渲染，以及Core Image用于图像的后处理。它不是一个简单的 Demo，而是一个将 AI 推理、实时图形处理和图像处理算法结合起来的实战案例。无论你是想学习如何集成和优化多个 CoreML 模型，还是想了解如何用 Metal 实现酷炫的视觉效果，甚至是研究如何设计一个鲁棒的图像处理流水线，这个项目都能给你带来不少启发。接下来，我就带你深入这个项目的“引擎盖”下面，看看它到底是怎么工作的。

2. 深度图生成：双轨制策略解析

获取深度信息是整个效果的基石。3Dify 采用了非常务实的“双轨制”策略，根据设备能力动态选择最优路径，这在实际应用开发中是很值得借鉴的设计思路。

2.1 硬件优先：利用系统原生视差数据

对于支持人像模式的 iPhone（通常是双摄及以上机型），系统在拍摄人像照片时，除了生成一张漂亮的虚化照片，其实还在后台默默计算了一张“视差图”。这张图本质上就是深度图的一种表现形式，记录了场景中不同物体的相对距离。

在代码层面，这主要通过AVFoundation框架的AVCaptureDepthDataOutput来实现。当你在AVCapturePhotoOutput的capturePhoto委托方法中收到一个AVCapturePhoto对象时，可以检查其depthData属性。如果该属性不为nil，恭喜你，设备提供了原生的深度数据。

func photoOutput(_ output: AVCapturePhotoOutput, didFinishProcessingPhoto photo: AVCapturePhoto, error: Error?) { guard let pixelBuffer = photo.pixelBuffer else { return } if let depthData = photo.depthData { // 设备支持，直接使用系统提供的深度数据 let depthPixelBuffer = depthData.depthDataMap // 将 depthPixelBuffer 转换为可用于 Metal 的纹理或进行后续处理 processDepthMap(from: depthPixelBuffer, originalImage: pixelBuffer) } else { // 设备不支持，走软件算法路径 estimateDepthMap(from: pixelBuffer) } }

注意：系统提供的深度数据是AVDepthData类型，其内部的depthDataMap是一个CVPixelBuffer。这个缓冲区的精度通常是kCVPixelFormatType_DepthFloat16或kCVPixelFormatType_DisparityFloat16，值范围是 0.0 到 1.0（或经过归一化处理）。直接使用前，需要确认其格式并进行可能的归一化处理，以适配后续的渲染管线。

这种方式获取的深度图质量最高、速度最快（因为是硬件计算），且完全免费（不消耗额外算力）。所以，在条件允许时，优先使用硬件方案是毋庸置疑的最佳实践。

2.2 软件兜底：基于 CoreML 的单目深度估计

对于绝大多数没有多摄像头的设备，我们就需要请出 AI 来帮忙“猜”深度了。这属于“单目深度估计”问题，即从一张普通的 2D 图片中推断出每个像素的深度值。3Dify 项目没有把宝押在一个模型上，而是设计了一个精巧的“模型委员会”投票机制，融合了三个不同的 CoreML 模型的结果，以追求更稳定、更准确的效果。

为什么需要多个模型？因为不同的深度估计模型各有优劣。有的擅长处理室内场景的几何结构，有的对室外自然景物的边缘保持得更好，有的则速度极快。单一模型在面对复杂多变的真实世界照片时，很容易出现局部预测失败（例如把远处的窗户预测成近处的门）。通过集成多个模型，我们可以利用它们的互补性，平滑掉单个模型的错误，得到更鲁棒的整体预测。

项目选用的三个模型是：

1. FCRN (Fully Convolutional Residual Networks)：来自 Apple 官方提供的模型，基于 ResNet 架构，在 NYU Depth V2 等室内数据集上训练，对室内场景的结构预测相对较好。
2. FastDepth：顾名思义，主打一个“快”。它采用了轻量化的编码器-解码器结构，推理速度有优势，适合对实时性要求高的场景。
3. Pydnet：一个专注于高分辨率深度估计的模型，其设计考虑了多尺度特征融合，在保持边缘清晰度方面往往表现不错。

这三个模型代表了深度估计中速度、精度和场景适应性等不同维度的权衡。将它们组合使用，是项目在精度和泛化能力上做的一个很有意义的探索。

3. 核心流水线：多模型融合与优化

当设备不支持硬件深度图时，3Dify 就会启动它自定义的 CoreML 处理流水线。这个流水线是项目的智慧核心，它不仅仅是将三个模型跑一遍然后取平均那么简单，而是包含了一套完整的质量评估与融合策略。

3.1 并行推理与初步处理

流水线的第一步是并行运行三个 CoreML 模型。为了提高效率，这三个推理任务应该被分发到不同的 Dispatch Queue 中并发执行，或者利用MLModelConfiguration的computeUnits属性合理分配 CPU、GPU 或 Neural Engine 资源。

每个模型输出一个代表深度估计的MLMultiArray。这里有一个关键细节：不同模型的输出值范围可能不同。有的输出是绝对的深度值（单位可能是米），有的输出是相对的视差值（无单位，0-1之间）。在进行任何比较或融合之前，必须对它们的输出进行归一化，统一到相同的尺度（例如 0.0 表示最近，1.0 表示最远）。

func normalizeDepthArray(_ multiArray: MLMultiArray) -> [Float] { // 假设 multiArray 形状为 [1, Height, Width] let count = multiArray.count var floatValues = [Float](repeating: 0.0, count: count) // 转换为 Float 数组 for i in 0..<count { floatValues[i] = multiArray[i].floatValue } // 找到最小值和最大值进行归一化 guard let minVal = floatValues.min(), let maxVal = floatValues.max(), maxVal > minVal else { return floatValues // 避免除零 } let range = maxVal - minVal let normalizedValues = floatValues.map { ($0 - minVal) / range } return normalizedValues }

归一化后，我们就得到了三张尺度一致的、代表深度估计的灰度图数据。

3.2 基于 Sobel 算子的质量评估

接下来是最巧妙的一步：如何自动判断哪张深度图的质量更好？项目采用的方法是计算每张深度图与原始输入图像的结构一致性误差。

其背后的逻辑是：在大多数情况下，图像中物体的边缘（颜色、亮度突变的地方）也应该对应着深度的不连续（即边缘）。例如，一个人站在背景前，他的轮廓既是颜色边缘，也应该是深度边缘。

具体操作如下：

1. 计算边缘图：对原始 RGB 图像和每一张归一化后的深度图，分别应用 Sobel 算子。Sobel 算子是一种边缘检测算子，它能计算出图像在水平和垂直方向上的梯度，从而得到边缘强度图。我们可以将两个方向的梯度幅值合并，得到一张代表“边缘在哪里”的图。
2. 计算差异：对于每一张深度边缘图，计算它与原始图像边缘图对应像素点的差异。理想情况下，两者的边缘应该重合，差异很小。
3. 计算 RMS 误差：将所有像素的差异值平方、求平均、再开方，得到一个标量值，即均方根误差。这个 RMS 值越小，说明这张深度图估计的边缘与原始图像的真实边缘越吻合，我们认为它的质量越高。

func evaluateDepthQuality(originalImage: CGImage, depthMap: [Float], width: Int, height: Int) -> Float { // 1. 将原始图像转换为灰度图，并计算其 Sobel 边缘图 let originalSobel = sobelFilter(image: originalImage) // 2. 将深度图数组转换为灰度图像数据，并计算其 Sobel 边缘图 let depthCGImage = createCGImage(from: depthMap, width: width, height: height) let depthSobel = sobelFilter(image: depthCGImage) // 3. 计算两个 Sobel 图的差异 RMS var sumOfSquaredDifferences: Float = 0.0 let pixelCount = width * height // 此处需要从 originalSobel 和 depthSobel 中获取像素数据进行计算 // 假设我们有两个 Float 数组 originalEdgeData 和 depthEdgeData for i in 0..<pixelCount { let diff = originalEdgeData[i] - depthEdgeData[i] sumOfSquaredDifferences += diff * diff } let meanSquaredError = sumOfSquaredDifferences / Float(pixelCount) let rmsError = sqrt(meanSquaredError) return rmsError }

3.3 自适应加权融合

拿到三张深度图（D_fast, D_fcrn, D_pyd）和它们对应的三个质量分数（RMS_fast, RMS_fcrn, RMS_pyd）后，就可以进行融合了。一个直观的想法是：质量越好的图，在最终结果中的权重应该越大。

我们可以将 RMS 误差的倒数作为权重的依据。因为 RMS 误差越小越好，其倒数就越大。需要对权重进行归一化，使得所有权重之和为 1。

let rmsValues = [rmsFast, rmsFcrn, rmsPydnet] // 避免除零错误，给 RMS 加一个很小的数 let epsilon: Float = 1e-6 let weights = rmsValues.map { 1.0 / ($0 + epsilon) } let sumWeights = weights.reduce(0, +) let normalizedWeights = weights.map { $0 / sumWeights } // 加权融合 let finalDepthMap = (0..<pixelCount).map { i in let dFast = depthFast[i] let dFcrn = depthFcrn[i] let dPyd = depthPyd[i] return dFast * normalizedWeights[0] + dFcrn * normalizedWeights[1] + dPyd * normalizedWeights[2] }

这种自适应加权融合，比简单平均或固定权重融合更能适应不同图像内容，理论上能获得更优的融合效果。

3.4 双边滤波：保边平滑

经过融合得到的深度图，可能还存在一些噪声或不平滑的区域。直接使用高斯模糊会模糊掉重要的边缘，导致 3D 效果中物体轮廓虚化。因此，项目最后一步使用了双边滤波。

双边滤波是一种非常有效的“保边平滑”滤波器。它不仅仅考虑像素之间的空间距离（像高斯模糊那样），还考虑像素之间的亮度（或颜色）相似性。对于深度图来说，我们使用原始彩色图像作为引导。

原理简述：在滤波一个像素点时，它会查看周围的邻居。如果某个邻居在空间上离得远，或者它的颜色（来自原图）与中心像素颜色差异很大，那么这个邻居的权重就会降低。这样一来，在物体内部（颜色相近的区域），滤波效果明显，能平滑噪声；而在物体边缘（颜色突变的区域），滤波效果很弱，从而保留了清晰的边缘。

在 iOS 开发中，我们可以利用Core Image的CIBilateralFilter滤镜方便地实现这一效果。关键是要把原始彩色图像作为滤镜的inputImage，而把融合后的深度图作为inputDisparityImage（或通过自定义CIKernel来实现更复杂的双边滤波逻辑）。

func applyBilateralFilter(to depthPixelBuffer: CVPixelBuffer, guidedBy originalImage: CIImage) -> CIImage? { let depthImage = CIImage(cvPixelBuffer: depthPixelBuffer) guard let bilateralFilter = CIFilter(name: "CIBilateralFilter") else { return nil } bilateralFilter.setValue(originalImage, forKey: kCIInputImageKey) // 注意：标准 CIBilateralFilter 可能不直接接受深度图作为引导。 // 更常见的做法是将深度图作为另一输入，或使用自定义 Kernel。 // 这里需要根据项目实际实现调整。 bilateralFilter.setValue(10.0, forKey: kCIInputRadiusKey) // 空间距离参数 bilateralFilter.setValue(0.1, forKey: kCIInputSharpnessKey) // 颜色差异参数 return bilateralFilter.outputImage }

经过双边滤波处理后，我们得到了一张既平滑（减少了噪声和估计不一致带来的块状感）又边缘清晰（保持了物体轮廓）的最终深度图，为后续的 3D 渲染做好了准备。

4. 3D 渲染：Metal 驱动的视差遮挡映射

有了高质量的深度图，下一步就是让它“动”起来，产生 3D 视差效果。3Dify 使用 Metal 来实现高性能的实时渲染，其核心技术是视差遮挡映射。

4.1 视差遮挡映射原理浅析

这不是真正的 3D 几何建模，而是一种基于纹理的先进渲染技术，用来模拟复杂表面的凹凸细节，成本远低于使用大量多边形。

1. 基础视差映射：在片段着色器中，我们根据表面法线和视线方向，对纹理坐标进行偏移。偏移量由深度图（在这里作为高度图）的值决定。深度值大的地方（更“凹”进去或更远），偏移就大一些，这样在斜着看的时候，这些地方就会被“遮挡”，看起来就像有深度。这是最基础的版本，但容易在陡峭角度产生纹理拉伸或失真。
2. 视差遮挡映射的改进：POM 是对基础视差映射的增强。它不再是简单的一次性偏移，而是采用“步进射线追踪”的思想。从表面沿着视线方向“步进”一段距离，每一步都采样深度图，检查当前采样点的高度是否低于（即被遮挡）射线当前的高度。一旦发现被遮挡，就回退一步并进行更精细的查找，从而找到更精确的交点。这种方法能产生更正确的遮挡关系，视觉效果也更真实。

在 3Dify 的场景中，我们可以将整张照片视为一个垂直于屏幕的平面。深度图定义了这张平面上每个点沿着屏幕法线方向的“偏移量”。当手机陀螺仪检测到设备角度变化时，我们相应地改变虚拟的“视线方向”，在着色器中根据这个方向和每个像素的深度值，动态地偏移纹理采样坐标，从而模拟出观察角度变化时，近处物体移动快、远处物体移动慢的 3D 视差效果。

4.2 Metal 着色器实现要点

在 Metal Shading Language (MSL) 中，片段着色器是实现 POM 的核心。以下是一个高度简化的伪代码逻辑，用于阐述概念：

fragment float4 parallaxOcclusionMappingFragment(VertexOut in [[stage_in]], texture2d<float> colorTexture [[texture(0)]], texture2d<float> depthTexture [[texture(1)]], constant float3 &viewDirection [[buffer(0)]], constant float &parallaxScale [[buffer(1)]]) { constexpr sampler textureSampler(mag_filter::linear, min_filter::linear); // 1. 将视线方向从世界/视图空间转换到切线空间（假设已在顶点着色器中完成） float3 V = normalize(in.tangentViewDir); // 2. 计算初始的纹理坐标偏移量。 // 深度值从深度纹理中采样，parallaxScale 是控制整体视差强度的缩放因子。 float initialDepth = depthTexture.sample(textureSampler, in.uv).r; float2 initialOffset = (V.xy / V.z) * initialDepth * parallaxScale; // 3. 基础视差映射：直接偏移 // float2 displacedUV = in.uv - initialOffset; // float4 color = colorTexture.sample(textureSampler, displacedUV); // 4. 视差遮挡映射（POM） - 步进搜索 const float numLayers = 32.0; // 分层数量，影响质量与性能 float layerDepth = 1.0 / numLayers; float currentLayerDepth = 0.0; float2 deltaUV = initialOffset / numLayers; float2 currentUV = in.uv; float currentDepthMapValue = depthTexture.sample(textureSampler, currentUV).r; // 步进循环，寻找遮挡点 while(currentLayerDepth < currentDepthMapValue) { currentUV -= deltaUV; currentDepthMapValue = depthTexture.sample(textureSampler, currentUV).r; currentLayerDepth += layerDepth; } // 5. 二分查找，精确定位交点（可选但推荐） float2 prevUV = currentUV + deltaUV; float afterDepth = currentDepthMapValue - currentLayerDepth; float beforeDepth = depthTexture.sample(textureSampler, prevUV).r - (currentLayerDepth - layerDepth); float weight = afterDepth / (afterDepth - beforeDepth); float2 finalUV = mix(currentUV, prevUV, weight); // 6. 使用最终计算出的 UV 坐标采样颜色纹理 float4 color = colorTexture.sample(textureSampler, finalUV); // 7. 可选的边缘处理：如果步进超出纹理边界，可以采样一个低细节的备用颜色 if(finalUV.x < 0.0 || finalUV.x > 1.0 || finalUV.y < 0.0 || finalUV.y > 1.0) { color = colorTexture.sample(textureSampler, in.uv); // 回退到原始UV } return color; }

关键参数与调优：

• parallaxScale：这是最重要的控制参数。它决定了 3D 效果的“强度”。值太小时效果不明显；值太大时，会导致严重的纹理拉伸甚至穿帮。通常需要根据深度图的数值范围进行反复调试，并与设备陀螺仪的灵敏度联动，找到一个视觉舒适且稳定的值。
• numLayers：分层数。增加层数可以提高遮挡关系的精度，尤其是对于深度变化剧烈的区域，但也会增加着色器的计算负担。在移动设备上，需要在效果和性能之间取得平衡，通常 20-40 层是一个合理的范围。
• 深度图预处理：传入着色器的深度图，可能需要根据渲染需求进行反转（近处为1，远处为0）或重新映射，确保其与 POM 算法的期望输入一致。

4.3 与陀螺仪联动

为了产生响应设备运动的动态效果，我们需要将设备的姿态（通过CoreMotion框架获取）转化为着色器中的视线方向。

1. 获取设备姿态：使用CMMotionManager订阅.deviceMotion更新，获取attitude（姿态）。通常我们关心的是相对于初始参考系（例如应用启动时）的旋转。
2. 构造视图矩阵：根据姿态（四元数或旋转矩阵）构造一个简单的视图矩阵。因为我们渲染的是一个全屏四边形，相机可以假设固定在正前方。
3. 计算视线向量：视线向量就是从相机位置指向屏幕上每个点的向量。在顶点着色器中，我们可以将相机空间（或世界空间）的视图方向转换到每个顶点的切线空间，然后传递给片段着色器。更简单的一种方法是，根据设备旋转，直接计算一个全局的、近似代表视线变化的方向向量，传递给片段着色器。这个向量可以基于设备姿态的俯仰角（pitch）和偏航角（yaw）来构造。
4. 传递到着色器：将计算出的视线方向（归一化后的三维向量）通过MTLRenderPassDescriptor的fragmentBuffers或一个统一的MTLBuffer传递给 Metal 着色器。

这样，当用户倾斜设备时，陀螺仪数据更新，传递给着色器的视线方向随之改变，POM 算法根据新的方向计算偏移，从而实时更新渲染结果，产生流畅的 3D 视差动画。

5. 性能优化与实战心得

将 CoreML 推理、图像处理和 Metal 实时渲染组合在一起，对移动设备的性能是一个不小的挑战。在实际实现和调试类似项目时，我积累了一些关键的优化心得和避坑指南。

5.1 CoreML 模型推理优化

1. 模型格式与精度：确保使用的 CoreML 模型是.mlmodelc（编译后）格式，而不是.mlmodel。首次加载模型时，Xcode 会将其编译为优化后的格式，这个过程可能较慢，但后续运行会快很多。如果可能，使用低精度（FP16）的模型，它们在 Neural Engine 上运行更快、功耗更低。
2. 计算单元选择：创建MLModelConfiguration时，明确设置computeUnits。对于深度估计这种复杂模型，优先尝试.all（允许系统优化分配）或.cpuAndNeuralEngine。如果模型不支持 Neural Engine，则回退到.cpuAndGPU。避免只使用.cpuOnly，除非进行性能基准测试。
3. 输入输出预处理：CoreML 模型对输入图像的尺寸、颜色空间（通常是 RGB）、数值范围（如 0-1 或 0-255）有严格要求。务必使用VNImageRequestHandler或手动将CVPixelBuffer调整到模型期望的格式，否则会导致推理错误或性能下降。输出MLMultiArray的解析也要注意维度和数据类型。
4. 异步与缓存：三个模型的推理是独立的，一定要放在不同的队列中异步执行，最后再同步结果。对于用户可能反复查看的同一张图片，可以将计算好的深度图缓存起来，避免重复推理。

5.2 图像处理流水线优化

1. 活用 Core Image 与 vImage：对于 Sobel 滤波、图像归一化、像素级运算等操作，优先考虑使用高度优化的Core Image滤镜或Accelerate框架的vImage函数。它们经过高度优化，能充分利用 CPU 的 SIMD 指令集，速度远超手写的循环。
2. 避免 CPU/GPU 频繁拷贝：深度图数据可能在 CPU 端（用于 CoreML 后处理）和 GPU 端（用于 Metal 渲染）都需要。尽量减少CVPixelBuffer或MTLTexture在 CPU 和 GPU 内存之间的拷贝次数。如果可能，让 CoreML 的输出直接进入 GPU 可访问的内存（如CVPixelBuffer配合IOSurface），或者使用MTLDevice的makeTexture方法从CVPixelBuffer创建纹理，这些操作通常是零拷贝或高效拷贝。
3. 双边滤波的权衡：CIBilateralFilter效果虽好，但计算量较大，尤其是对于高分辨率图片。可以考虑在降采样后的图像上进行滤波，或者将滤波强度（inputRadius）参数调低。在移动设备上，实时性往往比极致的平滑效果更重要。

5.3 Metal 渲染性能调优

1. 纹理尺寸与格式：传递给 Metal 的深度图纹理，不需要和原图一样大。通常，将深度图下采样到原图的 1/2 或 1/4，在片段着色器中进行采样时，视觉差异并不明显，但能显著减少纹理读取带宽和 POM 步进计算量。纹理格式使用MTLPixelFormatR8Unorm（8位灰度）通常就足够了。
2. 着色器复杂度：POM 的步进循环是性能热点。务必严格控制numLayers（分层数）。可以设计一个根据设备性能（如通过MTLDevice的supportsFamily查询）动态调整层数的机制。高端设备用更多层，低端设备用较少层。
3. 渲染管线状态缓存：提前创建并复用MTLRenderPipelineState对象，避免在渲染循环中创建。
4. 帧率控制与功耗：使用CADisplayLink进行屏幕刷新同步。但要注意，如果计算（深度估计）耗时过长，会导致掉帧。一个策略是：将深度计算放在后台线程，计算完成后更新深度图纹理。渲染线程每一帧都使用当前最新的深度图。如果深度图还没更新完，就继续使用上一帧的。这样可以保证渲染的流畅性，代价是深度变化可能会有延迟，但对于静态图片的浏览来说是可以接受的。

5.4 常见问题与排查技巧

1. 效果不明显或反向：

   • 检查深度图极性：确认深度图中，亮色代表近还是远。不同的模型和数据处理流程可能导致极性相反。在融合或渲染前，可能需要对深度图进行1.0 - depth的反转操作。
   • 调整parallaxScale：这是最常用的调节旋钮。在调试界面中添加一个滑块实时调整该参数，找到最适合当前图片的值。
   • 检查视线方向：确保从陀螺仪到着色器的视线方向向量计算正确。可以尝试固定一个测试方向（如float3(0, 0, 1)），看看是否有基础视差效果。

2. 边缘出现黑色或扭曲：

   • POM 边界处理：如着色器伪代码所示，当步进搜索导致 UV 坐标超出 [0, 1] 范围时，会出现采样错误。务必添加边界检查，并回退到原始 UV 坐标或进行夹紧（clamp）采样。
   • 深度图边缘问题：AI 模型对图像边缘的深度预测通常不准。可以考虑对深度图边缘进行轻微羽化或使用原图边缘检测来弱化边缘区域的视差效果。

3. 性能卡顿：

   • 使用 Instruments 分析：Xcode 的 Instruments 工具是性能分析的利器。用Time Profiler查找 CPU 热点（很可能是 CoreML 推理或图像处理循环），用Metal System Trace分析 GPU 负载和渲染指令耗时。
   • 分帧计算：如果单次深度估计流水线耗时超过 100ms，考虑将其分解为多个步骤，分摊到连续的多帧中去完成，避免阻塞主线程导致界面卡顿。

4. 内存占用过高：

   • 及时释放资源：大的CVPixelBuffer、CIImage、MTLTexture在用完后要及时置为nil。特别是在处理多张图片时，避免持有不再需要的中间数据。
   • 监控内存警告：在AppDelegate或视图控制器中监听UIApplication.didReceiveMemoryWarningNotification，收到警告时主动清理缓存和可重建的中间数据。

这个项目将前沿的 AI 推理与实时的图形渲染相结合，在移动设备上实现了令人印象深刻的 2D 转 3D 效果。其架构设计，特别是针对不同硬件的双轨制策略和多模型融合的流水线，体现了很强的工程实用性。在复现或借鉴类似思路时，关键在于理解每个环节的输入输出、数据格式转换以及性能瓶颈所在，然后根据自己应用的具体需求（是追求极致效果还是流畅体验）进行有针对性的调整和优化。