lingbot-depth-pretrain-vitl-14实战手册：Python脚本批量处理文件夹内RGB图像深度估计

lingbot-depth-pretrain-vitl-14实战手册：Python脚本批量处理文件夹内RGB图像深度估计

1. 引言：从单张测试到批量生产的跨越

如果你已经按照快速指南，在Web界面上传了一张图片，点击按钮，成功看到了深度图，那么恭喜你，你已经完成了第一步。但你可能马上会想：这确实很酷，但我的项目里有成百上千张图片，难道要一张张手动上传吗？效率太低了。

这正是本文要解决的问题。我们将从“点一下，看一张”的演示模式，升级到“写一次，跑一批”的工程化模式。通过编写一个简单的Python脚本，你可以让lingbot-depth模型自动遍历整个文件夹，处理里面的所有RGB图像，并整齐地保存好每一张深度图。无论是处理一个产品拍摄目录，还是一个自动驾驶数据集，这个方法都能帮你把重复劳动交给代码。

本文将手把手带你完成这个升级。你不需要是Python专家，只要会基本的命令行操作，就能跟着做下来。我们会从最基础的脚本写起，逐步加入错误处理、进度显示等实用功能，最终得到一个稳定可靠的批量处理工具。

2. 环境准备与快速检查

在开始写代码之前，我们需要确认两件事：你的镜像实例正在运行，并且你知道如何访问它。

2.1 确认服务状态

首先，确保你已经按照快速指南部署了ins-lingbot-depth-vitl14-v1镜像，并且实例状态显示为“已启动”。如果还没做，可以回到文章开头的“快速试用”部分完成部署。

部署成功后，你有两种方式访问模型：

• Web界面：通过http://<你的实例IP>:7860在浏览器中打开可视化界面
• API接口：通过http://<你的实例IP>:8000的REST API进行程序化调用

我们的批量脚本将使用第二种方式——API接口。因为API可以被代码直接调用，适合自动化处理。

2.2 测试API连通性

在写正式脚本前，我们先做个快速测试，确保API工作正常。打开你的终端（Linux/Mac的终端，或Windows的PowerShell/CMD），输入以下命令：

curl -X POST "http://<你的实例IP>:8000/predict" \ -H "Content-Type: application/json" \ -d '{ "image_path": "/root/assets/lingbot-depth-main/examples/0/rgb.png", "mode": "monocular" }'

把<你的实例IP>替换成你实例的实际IP地址。如果一切正常，你会看到一个很长的JSON响应，里面包含status: "success"和depth_image_base64（一串编码后的图像数据）。

如果看到类似Connection refused的错误，请检查：

1. 实例是否真的启动了（状态显示“已启动”）
2. IP地址是否正确
3. 端口是否是8000（不是7860）

这个测试验证了API可以正常工作，接下来我们就可以基于它来构建批量处理脚本了。

3. 基础批量处理脚本编写

现在我们来编写第一个版本的批量处理脚本。这个脚本会完成最核心的功能：读取文件夹中的所有图片，依次调用API处理，保存结果。

3.1 创建脚本文件

在你的本地电脑上，创建一个新的Python文件，比如命名为batch_process.py。你可以用任何文本编辑器来创建它，比如VS Code、Sublime Text，甚至记事本也可以。

3.2 完整脚本代码

下面是完整的脚本代码，我会逐段解释每一部分的作用：

import os import json import base64 import requests from PIL import Image import numpy as np import time from pathlib import Path class LingBotDepthBatchProcessor: def __init__(self, api_url="http://localhost:8000/predict"): """ 初始化批量处理器 :param api_url: LingBot-Depth API的地址 """ self.api_url = api_url self.supported_extensions = {'.jpg', '.jpeg', '.png', '.bmp', '.tiff'} def is_image_file(self, file_path): """检查文件是否是支持的图像格式""" return Path(file_path).suffix.lower() in self.supported_extensions def read_image_as_base64(self, image_path): """将图像读取为base64编码的字符串""" with open(image_path, 'rb') as f: image_bytes = f.read() return base64.b64encode(image_bytes).decode('utf-8') def save_depth_image(self, depth_base64, output_path): """将base64编码的深度图保存为PNG文件""" # 解码base64数据 depth_bytes = base64.b64decode(depth_base64) # 保存为PNG文件 with open(output_path, 'wb') as f: f.write(depth_bytes) print(f"深度图已保存: {output_path}") def save_depth_data(self, depth_array, output_path): """将深度数据保存为.npy文件（原始浮点数据）""" np.save(output_path, depth_array) print(f"深度数据已保存: {output_path}") def process_single_image(self, image_path, output_dir, mode="monocular"): """ 处理单张图像 :param image_path: 输入图像路径 :param output_dir: 输出目录 :param mode: 处理模式，'monocular'或'completion' :return: 处理是否成功 """ try: print(f"正在处理: {image_path}") # 准备请求数据 image_base64 = self.read_image_as_base64(image_path) payload = { "image_base64": image_base64, "mode": mode, "return_numpy": True # 同时返回numpy数组 } # 发送请求到API start_time = time.time() response = requests.post(self.api_url, json=payload, timeout=30) end_time = time.time() if response.status_code != 200: print(f"处理失败，状态码: {response.status_code}") print(f"错误信息: {response.text}") return False # 解析响应 result = response.json() if result.get("status") != "success": print(f"处理失败: {result.get('message', '未知错误')}") return False # 创建输出文件名（保持原文件名） input_filename = Path(image_path).stem output_prefix = os.path.join(output_dir, input_filename) # 保存深度图（伪彩色PNG） depth_image_base64 = result.get("depth_image_base64") if depth_image_base64: depth_image_path = f"{output_prefix}_depth.png" self.save_depth_image(depth_image_base64, depth_image_path) # 保存深度数据（原始浮点.npy） depth_data_base64 = result.get("depth_data_base64") if depth_data_base64: # 解码base64的numpy数据 depth_bytes = base64.b64decode(depth_data_base64) depth_array = np.frombuffer(depth_bytes, dtype=np.float32) # 重塑为2D数组 height = result.get("height", 480) width = result.get("width", 640) depth_array = depth_array.reshape((height, width)) depth_data_path = f"{output_prefix}_depth.npy" self.save_depth_data(depth_array, depth_data_path) # 打印处理信息 process_time = end_time - start_time depth_range = result.get("depth_range", "N/A") print(f"处理完成! 耗时: {process_time:.2f}秒, 深度范围: {depth_range}") return True except Exception as e: print(f"处理图像时发生错误: {str(e)}") return False def process_folder(self, input_folder, output_folder, mode="monocular"): """ 批量处理文件夹中的所有图像 :param input_folder: 输入文件夹路径 :param output_folder: 输出文件夹路径 :param mode: 处理模式 """ # 创建输出文件夹 os.makedirs(output_folder, exist_ok=True) # 获取所有图像文件 image_files = [] for file in os.listdir(input_folder): file_path = os.path.join(input_folder, file) if os.path.isfile(file_path) and self.is_image_file(file_path): image_files.append(file_path) if not image_files: print(f"在文件夹 {input_folder} 中未找到支持的图像文件") return print(f"找到 {len(image_files)} 张待处理图像") print("开始批量处理...") print("-" * 50) # 统计处理结果 success_count = 0 fail_count = 0 # 依次处理每张图像 for i, image_path in enumerate(image_files, 1): print(f"\n[{i}/{len(image_files)}] ", end="") success = self.process_single_image(image_path, output_folder, mode) if success: success_count += 1 else: fail_count += 1 # 打印统计信息 print("\n" + "=" * 50) print("批量处理完成!") print(f"成功: {success_count} 张") print(f"失败: {fail_count} 张") print(f"输出目录: {output_folder}") # 使用示例 if __name__ == "__main__": # 配置参数 API_URL = "http://<你的实例IP>:8000/predict" # 替换为你的实例IP INPUT_FOLDER = "./input_images" # 输入图像文件夹 OUTPUT_FOLDER = "./output_depth" # 输出文件夹 PROCESS_MODE = "monocular" # 处理模式: "monocular" 或 "completion" # 创建处理器并运行 processor = LingBotDepthBatchProcessor(api_url=API_URL) processor.process_folder(INPUT_FOLDER, OUTPUT_FOLDER, mode=PROCESS_MODE)

3.3 脚本使用说明

这个脚本的使用非常简单，只需要修改三个参数：

1. API_URL：改成你的实例IP地址，比如"http://192.168.1.100:8000/predict"
2. INPUT_FOLDER：输入图像所在的文件夹路径
3. OUTPUT_FOLDER：深度图输出文件夹路径
4. PROCESS_MODE：处理模式，一般用"monocular"（单目深度估计）

使用步骤：

1. 创建一个文件夹（比如input_images），把所有要处理的RGB图片放进去
2. 运行脚本：python batch_process.py
3. 等待处理完成，结果会保存在output_depth文件夹中

每个输入图像会生成两个输出文件：

• 原文件名_depth.png：伪彩色深度图，方便可视化查看
• 原文件名_depth.npy：原始深度数据（浮点数），用于后续计算

4. 高级功能与实用技巧

基础脚本已经能完成批量处理，但在实际项目中，我们可能还需要一些增强功能。下面介绍几个实用的扩展。

4.1 添加进度条和详细日志

处理大量图片时，有个进度条会友好很多。我们可以使用tqdm库来添加进度显示：

# 首先安装tqdm: pip install tqdm from tqdm import tqdm import logging class EnhancedBatchProcessor(LingBotDepthBatchProcessor): def __init__(self, api_url="http://localhost:8000/predict", log_file="batch_process.log"): super().__init__(api_url) # 设置日志 logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s', handlers=[ logging.FileHandler(log_file), logging.StreamHandler() ] ) self.logger = logging.getLogger(__name__) def process_folder(self, input_folder, output_folder, mode="monocular"): """增强版的文件夹处理，带进度条和日志""" os.makedirs(output_folder, exist_ok=True) # 获取图像文件 image_files = [] for file in os.listdir(input_folder): file_path = os.path.join(input_folder, file) if os.path.isfile(file_path) and self.is_image_file(file_path): image_files.append(file_path) if not image_files: self.logger.warning(f"在文件夹 {input_folder} 中未找到图像文件") return self.logger.info(f"开始处理 {len(image_files)} 张图像") success_count = 0 fail_count = 0 failed_files = [] # 使用tqdm显示进度条 with tqdm(total=len(image_files), desc="处理进度", unit="张") as pbar: for image_path in image_files: filename = os.path.basename(image_path) try: success = self.process_single_image(image_path, output_folder, mode) if success: success_count += 1 self.logger.info(f"成功处理: {filename}") else: fail_count += 1 failed_files.append(filename) self.logger.error(f"处理失败: {filename}") except Exception as e: fail_count += 1 failed_files.append(filename) self.logger.error(f"处理异常 {filename}: {str(e)}") finally: pbar.update(1) # 生成处理报告 self.generate_report(output_folder, success_count, fail_count, failed_files) def generate_report(self, output_folder, success, fail, failed_files): """生成处理报告""" report_path = os.path.join(output_folder, "processing_report.txt") with open(report_path, 'w', encoding='utf-8') as f: f.write("=" * 50 + "\n") f.write("批量深度估计处理报告\n") f.write("=" * 50 + "\n\n") f.write(f"处理时间: {time.strftime('%Y-%m-%d %H:%M:%S')}\n") f.write(f"成功处理: {success} 张\n") f.write(f"处理失败: {fail} 张\n") f.write(f"成功率: {success/(success+fail)*100:.1f}%\n\n") if failed_files: f.write("失败文件列表:\n") for file in failed_files: f.write(f" - {file}\n") self.logger.info(f"处理报告已保存: {report_path}")

4.2 支持深度补全模式

如果你的数据包含稀疏深度图（比如来自LiDAR或ToF传感器），可以使用深度补全模式。这需要同时提供RGB图像和对应的深度图：

def process_with_sparse_depth(self, rgb_folder, depth_folder, output_folder): """ 处理RGB图像和对应的稀疏深度图（深度补全模式） :param rgb_folder: RGB图像文件夹 :param depth_folder: 稀疏深度图文件夹 :param output_folder: 输出文件夹 """ # 确保文件夹存在 os.makedirs(output_folder, exist_ok=True) # 获取RGB文件列表 rgb_files = [] for file in os.listdir(rgb_folder): if self.is_image_file(file): rgb_files.append(file) # 处理每对RGB-深度图像 for rgb_file in rgb_files: rgb_path = os.path.join(rgb_folder, rgb_file) # 假设深度图文件名与RGB图相同（或有关联规则） depth_file = rgb_file.replace('.jpg', '_depth.png') # 根据实际情况调整 depth_path = os.path.join(depth_folder, depth_file) if not os.path.exists(depth_path): print(f"警告: 未找到对应的深度图 {depth_file}") continue # 读取两张图像并合并为base64 rgb_base64 = self.read_image_as_base64(rgb_path) depth_base64 = self.read_image_as_base64(depth_path) # 准备请求数据（深度补全模式） payload = { "image_base64": rgb_base64, "depth_base64": depth_base64, # 稀疏深度图 "mode": "completion", # 深度补全模式 "camera_intrinsics": { "fx": 460.14, # 相机内参，根据实际情况填写 "fy": 460.20, "cx": 319.66, "cy": 237.40 } } # 发送请求并保存结果 response = requests.post(self.api_url, json=payload, timeout=30) if response.status_code == 200: result = response.json() if result.get("status") == "success": # 保存结果 output_prefix = os.path.join(output_folder, Path(rgb_file).stem) self.save_depth_image(result["depth_image_base64"], f"{output_prefix}_completed.png") print(f"深度补全完成: {rgb_file}")

4.3 图像预处理与后处理

有时候，输入图像可能需要一些预处理，或者输出深度图需要后处理。这里提供几个实用函数：

def preprocess_image(self, image_path, target_size=(448, 448)): """ 图像预处理：调整大小、归一化等 :param image_path: 图像路径 :param target_size: 目标尺寸（建议使用14的倍数） :return: 预处理后的base64图像 """ from PIL import Image # 打开图像 img = Image.open(image_path) # 调整大小（保持长宽比） img.thumbnail(target_size, Image.Resampling.LANCZOS) # 转换为RGB（如果是RGBA） if img.mode in ('RGBA', 'LA'): background = Image.new('RGB', img.size, (255, 255, 255)) background.paste(img, mask=img.split()[-1]) img = background elif img.mode != 'RGB': img = img.convert('RGB') # 保存到临时文件 temp_path = "temp_preprocessed.jpg" img.save(temp_path, "JPEG", quality=95) # 读取为base64 with open(temp_path, 'rb') as f: image_bytes = f.read() # 清理临时文件 os.remove(temp_path) return base64.b64encode(image_bytes).decode('utf-8') def postprocess_depth(self, depth_array, min_depth=0.1, max_depth=10.0): """ 深度图后处理：过滤异常值、平滑等 :param depth_array: 原始深度数组 :param min_depth: 最小深度阈值（米） :param max_depth: 最大深度阈值（米） :return: 处理后的深度数组 """ import cv2 # 1. 过滤异常值 depth_array = np.clip(depth_array, min_depth, max_depth) # 2. 中值滤波去噪（可选） # depth_array = cv2.medianBlur(depth_array.astype(np.float32), 3) # 3. 归一化到0-255（用于可视化） depth_normalized = (depth_array - min_depth) / (max_depth - min_depth) depth_normalized = np.clip(depth_normalized * 255, 0, 255).astype(np.uint8) # 4. 应用颜色映射（伪彩色） depth_colored = cv2.applyColorMap(depth_normalized, cv2.COLORMAP_INFERNO) return depth_array, depth_colored

5. 实战案例：处理室内场景数据集

让我们通过一个具体的例子，看看如何用这个脚本处理一个真实的室内场景数据集。

5.1 数据集准备

假设我们有一个室内场景的数据集，结构如下：

dataset/ ├── scene_001/ │ ├── rgb_001.jpg │ ├── rgb_002.jpg │ └── rgb_003.jpg ├── scene_002/ │ ├── rgb_001.jpg │ └── rgb_002.jpg └── scene_003/ ├── rgb_001.jpg ├── rgb_002.jpg └── rgb_003.jpg

5.2 批量处理脚本

我们可以编写一个专门的脚本来处理这种嵌套文件夹结构：

import glob def process_nested_folders(root_folder, output_root, api_url): """ 处理嵌套文件夹结构的数据集 :param root_folder: 数据集根目录 :param output_root: 输出根目录 :param api_url: API地址 """ processor = LingBotDepthBatchProcessor(api_url=api_url) # 查找所有子文件夹 scene_folders = glob.glob(os.path.join(root_folder, "scene_*")) for scene_folder in scene_folders: scene_name = os.path.basename(scene_folder) print(f"\n处理场景: {scene_name}") # 创建对应的输出文件夹 output_folder = os.path.join(output_root, scene_name) os.makedirs(output_folder, exist_ok=True) # 查找该场景下的所有RGB图像 rgb_files = glob.glob(os.path.join(scene_folder, "rgb_*.jpg")) if not rgb_files: print(f"在 {scene_folder} 中未找到RGB图像") continue # 批量处理 success_count = 0 for rgb_file in rgb_files: filename = os.path.basename(rgb_file) print(f" 处理: {filename}", end="") success = processor.process_single_image( rgb_file, output_folder, mode="monocular" ) if success: success_count += 1 print(" ✓") else: print(" ✗") print(f"场景 {scene_name} 完成: {success_count}/{len(rgb_files)} 成功") # 使用示例 if __name__ == "__main__": # 配置 API_URL = "http://192.168.1.100:8000/predict" DATASET_ROOT = "./dataset" OUTPUT_ROOT = "./depth_results" # 处理整个数据集 process_nested_folders(DATASET_ROOT, OUTPUT_ROOT, API_URL)

5.3 结果分析与可视化

处理完成后，我们可以对结果进行一些简单的分析和可视化：

def analyze_results(output_root): """ 分析批量处理结果 :param output_root: 输出根目录 """ import matplotlib.pyplot as plt # 收集所有深度数据 depth_files = glob.glob(os.path.join(output_root, "**", "*_depth.npy"), recursive=True) if not depth_files: print("未找到深度数据文件") return print(f"找到 {len(depth_files)} 个深度数据文件") # 统计深度范围 all_depths = [] depth_ranges = [] for depth_file in depth_files[:10]: # 只分析前10个，避免内存过大 depth_data = np.load(depth_file) valid_depths = depth_data[depth_data > 0] # 只考虑有效深度 if len(valid_depths) > 0: min_depth = np.min(valid_depths) max_depth = np.max(valid_depths) depth_ranges.append((min_depth, max_depth)) all_depths.extend(valid_depths.tolist()) # 打印统计信息 if all_depths: print(f"总体深度范围: {np.min(all_depths):.2f}m - {np.max(all_depths):.2f}m") print(f"平均深度: {np.mean(all_depths):.2f}m") print(f"深度中位数: {np.median(all_depths):.2f}m") # 绘制深度分布直方图 plt.figure(figsize=(10, 6)) plt.hist(all_depths, bins=50, alpha=0.7, color='blue', edgecolor='black') plt.xlabel('深度 (米)') plt.ylabel('像素数量') plt.title('深度分布直方图') plt.grid(True, alpha=0.3) plt.savefig(os.path.join(output_root, 'depth_distribution.png')) plt.close() print(f"深度分布图已保存: {os.path.join(output_root, 'depth_distribution.png')}") # 生成场景深度统计表 print("\n各场景深度统计:") print("-" * 40) print(f"{'场景':<15} {'最小深度(m)':<12} {'最大深度(m)':<12} {'平均深度(m)':<12}") print("-" * 40) scene_folders = glob.glob(os.path.join(output_root, "scene_*")) for scene_folder in scene_folders: scene_name = os.path.basename(scene_folder) depth_files = glob.glob(os.path.join(scene_folder, "*_depth.npy")) scene_depths = [] for depth_file in depth_files: depth_data = np.load(depth_file) valid_depths = depth_data[depth_data > 0] scene_depths.extend(valid_depths.tolist()) if scene_depths: min_depth = np.min(scene_depths) max_depth = np.max(scene_depths) avg_depth = np.mean(scene_depths) print(f"{scene_name:<15} {min_depth:<12.2f} {max_depth:<12.2f} {avg_depth:<12.2f}")

6. 常见问题与解决方案

在实际使用中，你可能会遇到一些问题。这里列出了一些常见问题及其解决方法：

6.1 连接问题

问题：脚本无法连接到API服务器

ConnectionError: HTTPConnectionPool(host='192.168.1.100', port=8000): Max retries exceeded with url: /predict

解决：

1. 检查实例IP地址是否正确
2. 确认实例状态为"已启动"
3. 检查防火墙设置，确保8000端口可访问
4. 尝试在浏览器中访问http://<IP>:8000/docs查看API文档是否正常

6.2 内存不足问题

问题：处理大图像时内存不足

CUDA out of memory. Tried to allocate...

解决：

1. 减小输入图像尺寸（建议使用448x448或336x336）
2. 在脚本中添加图像缩放预处理
3. 分批处理，不要一次性加载所有图像
4. 检查GPU显存使用情况

6.3 处理速度慢

问题：批量处理速度太慢

优化建议：

1. 使用多线程或异步处理（注意API服务器的并发限制）
2. 减少图像尺寸
3. 本地缓存已处理的图像，避免重复处理
4. 使用连接池复用HTTP连接

import concurrent.futures from requests.adapters import HTTPAdapter from requests.packages.urllib3.util.retry import Retry class OptimizedBatchProcessor(LingBotDepthBatchProcessor): def __init__(self, api_url, max_workers=4): super().__init__(api_url) # 创建带重试机制的会话 self.session = requests.Session() retry_strategy = Retry( total=3, backoff_factor=1, status_forcelist=[429, 500, 502, 503, 504] ) adapter = HTTPAdapter(max_retries=retry_strategy) self.session.mount("http://", adapter) self.session.mount("https://", adapter) self.max_workers = max_workers def process_folder_parallel(self, input_folder, output_folder, mode="monocular"): """并行处理文件夹中的图像""" os.makedirs(output_folder, exist_ok=True) # 获取所有图像文件 image_files = [] for file in os.listdir(input_folder): file_path = os.path.join(input_folder, file) if os.path.isfile(file_path) and self.is_image_file(file_path): image_files.append(file_path) print(f"找到 {len(image_files)} 张图像，开始并行处理...") # 使用线程池并行处理 with concurrent.futures.ThreadPoolExecutor(max_workers=self.max_workers) as executor: futures = [] for image_path in image_files: future = executor.submit( self.process_single_image_with_session, image_path, output_folder, mode ) futures.append(future) # 等待所有任务完成 success_count = 0 for future in concurrent.futures.as_completed(futures): try: if future.result(): success_count += 1 except Exception as e: print(f"任务执行出错: {str(e)}") print(f"并行处理完成，成功: {success_count}/{len(image_files)}") def process_single_image_with_session(self, image_path, output_dir, mode): """使用会话对象处理单张图像""" # 这里复用父类的process_single_image，但使用self.session # 需要稍微修改父类方法以支持传入session参数 # 具体实现略，可根据需要调整 pass

6.4 结果质量不理想

问题：生成的深度图质量不佳

改善方法：

1. 确保输入图像质量良好，避免模糊、过暗或过亮
2. 对于室内场景，保持适当的拍摄角度和光照
3. 尝试不同的图像尺寸（使用14的倍数）
4. 对于特定场景，可以考虑微调模型（如果有训练数据）

7. 总结与下一步建议

通过本文的介绍，你已经掌握了使用lingbot-depth-pretrain-vitl-14模型进行批量深度估计的完整流程。从最基础的单张图像测试，到编写自动化脚本处理整个文件夹，再到添加高级功能和优化处理速度，你现在应该能够自信地处理自己的图像数据集了。

7.1 关键要点回顾

1. 环境准备是关键：确保API服务正常运行，这是所有自动化的基础
2. 脚本要稳健：添加错误处理、日志记录和进度显示，让批量处理更可靠
3. 预处理很重要：适当调整图像尺寸和格式，能提升处理效果和速度
4. 结果要善用：深度图可以用于3D重建、避障导航、AR/VR等多种应用

7.2 实际应用建议

根据不同的使用场景，你可以考虑以下优化方向：

对于机器人导航项目：

• 实时处理视频流，而不仅仅是静态图像
• 将深度图转换为点云，用于路径规划
• 结合SLAM算法，实现实时定位与建图

对于3D重建应用：

• 处理多个角度的图像序列
• 使用深度图生成稠密点云
• 结合相机位姿，重建完整3D场景

对于AR/VR开发：

• 优化处理速度，满足实时性要求
• 处理动态场景，考虑时间一致性
• 集成到现有的AR/VR框架中

7.3 资源与扩展

如果你想进一步探索深度估计技术，这里有一些建议：

1. 学习更多模型：除了lingbot-depth，还可以尝试MiDaS、Depth Anything等其他深度估计模型
2. 了解原理：学习Vision Transformer和深度估计的基本原理
3. 实践项目：尝试用深度图完成一个完整的3D重建或机器人导航项目
4. 性能优化：学习如何优化模型推理速度，满足实时应用需求

批量处理只是第一步，真正的价值在于如何将这些深度信息应用到你的具体项目中。无论是学术研究还是产品开发，深度感知都能为你的系统增加"第三只眼"，让机器更好地理解三维世界。

获取更多AI镜像

想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。