自动驾驶-M2 感知与 BEV-2.3.4 BEVFormer 训练实战代码-相机覆盖 +GT 框
本节做一个重要的技术决策:不用官方仓库,自己实现精简版—— 理由在下面,这不是偷懒,是在你的硬件上唯一正确的选择。学习课程 端到端自动驾驶实战 | zhijia.dev

这个 图 相机覆盖+GT 框是怎么画的?请你进行详细的代码解释,另外,上图中的 3D 标注框,是怎么做的,结合 相机覆盖给我讲清楚,结合代码,讲清楚每一步、是如何做的,我怎么复现,并且打断点看实现的流程,将整个串起来,你就当我是小白,要讲的明明白白、透透彻彻,请你深入思考,要怎么给我讲,然后结合代码、流程图、图片示例讲清楚,我可以代码复现实现。
I'll write a standalone teaching script that breaks this down into numbered steps, run it, and use the actual output images in the explanation.
我写了一个教学脚本 learn_projection.py,把两张图的画法拆成 9 个步骤,每一步都会打印中间数据、保存一张图,并标好了建议打断点的位置。上面的 8 张图就是它在合成数据下的实际输出,不需要数据集就能跑。下面我对照代码和这些图,从头讲一遍。
0. 先记住一句话
这两张图背后其实是同一个公式:
[u·d, v·d, d, 1]ᵀ = lidar2img(4×4) @ [x, y, z, 1]ᵀ
像素 u = (u·d)/d, v = (v·d)/d
- 覆盖图(面板 ①):把 BEV 格子上的柱子点代入公式,看投影后落在哪个相机的画面里。
- 3D 框(相机图上的绿框):把框的 8 个角点代入公式,得到 8 个像素点后连成线。
这个公式和 SpatialCrossAttention 第 2 步用的是同一个。所以弄懂这两张图,也就弄懂了 BEVFormer 是怎么"拉取"图像特征的。
1. 先跑起来
conda activate ad
cd ~/carla/work/courses/M2/2.3 # 把 learn_projection.py 放到这里
# ① 合成数据(先用它理解原理,结果和上面的图一样)
python learn_projection.py --out ./learn_syn
# ② 你的真实数据(换成你截图里那一帧)
python learn_projection.py --root ../dataset_v4 --split val --frame 8 --out ./learn_real
# ③ 每一步都停下来,看变量
python learn_projection.py --pause
总流程图
┌──────────── lidar2img [6,4,4] ────────────┐
│ (数据集里由 相机内参K × 坐标轴换算A × 外参 合成)│
└──────────────┬─────────────────────────────┘
│ 同一个矩阵,两种用法
┌───────────────────────────┴───────────────────────────┐
【A. 覆盖图】 【B. 3D 框】
STEP2 BEV 网格 coords [16384,2] STEP6 一个框 (x,y,z,l,w,h,yaw)
│ 每格竖一根柱子,4 个高度 │ 框坐标系摆 4 个角 → 旋转 → 平移
STEP3/4 pts [65536,3] → 补1 → [65536,4] │ → BEV 角点 [4,2]
│ einsum 乘 lidar2img STEP7 加底面/顶面高度 → [8,3]
▼ │ 乘 lidar2img(同一个公式)
q [6,65536,4] → 除以 d → (u,v) STEP8 → 每个相机 8 个 (u,v,d)
│ 判断: d>0 且 0<u<W 且 0<v<H │ 判断: 至少 1 个角点在图内 → 画
valid [6,16384,4] → any(高度) → cov [6,16384] │ 14 条线,两端 d>1m 才画
▼ ▼
STEP5 按相机上色 + 重叠压暗 → [128,128,3] 相机图上的绿色线框
└──────────────────── STEP9 合到一张图 ───────────────────┘
2. 基础:lidar2img 是什么,它是怎么来的
2.1 四个坐标系
一个 3D 点要变成像素,中间要经过四个坐标系:
| 坐标系 | 原点 | 轴的方向 | 例子 |
|---|---|---|---|
| ① 自车系(ego) | 自车中心 | x 前、y 右、z 上(CARLA 约定) | GT 框、BEV 格子都用这个坐标系 |
| ② 相机机体系 | 相机光心 | 同样是 x 前、y 右、z 上,但跟着相机转 | — |
| ③ OpenCV 相机系 | 相机光心 | x 右、y 下、z 前(z 就是深度) | 计算机视觉的通用约定 |
| ④ 像素系 | 图像左上角 | u 向右、v 向下 | 最终画在图上的位置 |
lidar2img = K4 @ A4 @ ego2cam
③→④ 内参 ②→③ 换轴 ①→② 外参(相机装在哪、朝哪)
对应 build_lidar2img() 里的代码:
R = rot_z(np.radians(yaw_deg)) # 相机的朝向(相机→自车 的旋转)
t = np.asarray(pos) # 相机装在自车的哪个位置
ego2cam[:3,:3] = R.T # 外参取逆:自车→相机,旋转转置
ego2cam[:3, 3] = -R.T @ t # 平移取负
A = [[0,1,0], # cv_x = y(右→右)
[0,0,-1], # cv_y = -z(上→下,所以取负)
[1,0,0]] # cv_z = x(前→深度)
K = [[f,0,W/2],[0,f,H/2],[0,0,1]] # f = W / (2·tan(FOV/2))
课程自测代码里的
R = [[0,1,0],[0,0,-1],[1,0,0]]就是这里的 A。它的行列式是 -1,因为 CARLA 的 x前/y右/z上 是左手系,而 OpenCV 是右手系,这一步同时完成了换轴和左右手系的转换。
2.2 用一个真实数字手算一遍
脚本打印的 FRONT 相机矩阵如下(相机装在 (1.5, 0, 1.6),朝正前方,FOV 70°):
lidar2img[0] =
[[ 224. 319.91 0. -336. ]
[ 128. 0. -319.91 319.85]
[ 1. 0. 0. -1.5 ]
[ 0. 0. 0. 1. ]]
代入点 (19.75, 5.24, 0, 1),也就是 STEP 3 里的那个格子:
第1行: 224×19.75 + 319.91×5.24 + 0×0 − 336 = 5765.6 ← u·d
第2行: 128×19.75 + 0 − 319.91×0 + 319.85 = 2848.4 ← v·d
第3行: 1×19.75 − 1.5 = 18.25 ← d(深度)
u = 5765.6 / 18.25 = 315.8 v = 2848.4 / 18.25 = 156.0
每一项都有直观含义:
- 第 3 行就是 d = x − 1.5:深度等于"点离相机向前的距离",因为相机装在车头前方 1.5 米处。
- 第 1 行:u = 224 + 320 × y/d。点在右边(y>0)就往图像右侧偏,越远(d 越大)偏得越少,这就是"近大远小"。
- 第 2 行:v = 128 + 320 × (1.6 − z)/d。点比相机低(z < 1.6)就落在图像下半部分。
这个结果和脚本 STEP 3 打印的表格完全一致:
相机 z u·d v·d d(深度) u v 有效?
FRONT 0.0 5765.6 2848.4 18.25 315.8 156.0 ✓
建议你用笔把这一行算一遍。 算通了,后面的步骤就都只是"批量做这件事"。
2.3 STEP 1:从 lidar2img 反推相机参数(看 step1_rig.png)
数据集已经把 lidar2img 算好了,你可能不知道它内部是怎么拼出来的。describe_camera() 可以反过来从矩阵里求出相机的安装位置、朝向和 FOV:
C = -inv(M) @ t # 光心:满足 M·C + t = 0(深度为 0 的点就是相机自己)
fwd = M[2] / |M[2]| # 第3行 = 光轴方向(因为 d = 第3行·p + t₂)
yaw = atan2(fwd_y, fwd_x)
cx = M[0]·fwd ; fx = |M[0] − cx·fwd| → FOV = 2·atan(W / 2fx)
用真实数据跑的时候,这张表是检查数据最快的方法:位置应该和你在 CARLA 里挂传感器时写的 carla.Transform 一致,yaw 应该是 0/±55/180 这类角度,cx ≈ W/2、cy ≈ H/2(如果不是,说明缩放图像时没有同步缩放 K)。
3. Part A:覆盖图是怎么画出来的
STEP 2:BEV 网格(和 _make_coords 完全一样)
xs = np.linspace(pc, -pc, bev) # 行:第 0 行在前方 +51.2
ys = np.linspace(-pc, pc, bev) # 列:第 0 列在左边 -51.2
gx, gy = np.meshgrid(xs, ys, indexing='ij')
coords = np.stack([gx.ravel(), gy.ravel()], 1) # [16384, 2]
脚本的输出:
coords[ 0] = ( 51.20, -51.20) 行 0 列 0 ← 前方最远、最左
coords[ 127] = ( 51.20, 51.20) 行 0 列 127 ← 前方最远、最右
coords[ 128] = ( 50.39, -51.20) 行 1 列 0 ← 换到下一行
coords[16383] = (-51.20, 51.20) 行 127 列 127 ← 后方最远、最右
扁平索引 i 和 (行, 列) 的关系是 行, 列 = divmod(i, 128)。后面所有的 reshape 都依赖这个顺序。
STEP 3:追踪一根柱子(看 step3_one_pillar.png)
zs = np.linspace(-2.0, 4.0, 4) # [-2, 0, 2, 4],和 SCA 一样
pillar = np.c_[np.repeat(cell[None], 4, 0), zs] # [4,3]:同一个 (x,y),4 个高度
for n in range(6):
uv, d = project(pillar, l2i[n])
ok = in_image(uv, d, W, H) # d>0 且 0<u<W 且 0<v<H
图里能看到:格子 (19.8, 5.2) 只有 FRONT 4/4 有效,4 个点在图上排成一条竖线(z 从 -2 到 4,越高越靠上)。其余相机的失败原因分两种,表格里有区分:
✗ 落在图像外:在相机前方(d>0),但 u 超出了 0~448。比如 FRONT_LEFT 的 u=1225,说明这个点在它视野的右边外面。✗ 在相机背后(d≤0):比如 BACK 相机的 d=-21.25。这种点必须剔除,因为除以负数会把点翻转到图像的另一侧,看起来像落在了图里,实际上是错的。这就是代码里d > eps这个条件的用途。
这一步正是 SpatialCrossAttention 在每个格子上做的事:只是 SCA 会在那 4 个点上用 grid_sample 取特征,而覆盖图只记录"有没有落进图像"。
STEP 4:把所有格子一次算完(看 step4_per_camera.png)
一个格子一个格子地循环太慢,所以把 16384 个格子 × 4 个高度全部摊平,一次算完:
pts = np.c_[np.repeat(coords, 4, axis=0), # 每个格子复制 4 次
np.tile(zs, P)] # 高度循环铺开 → [65536, 3]
# 顺序:格子0的z0,z1,z2,z3, 格子1的z0..z3, ...
ph = np.c_[pts, np.ones(P*4)] # 齐次坐标 [65536, 4]
q = np.einsum('nij,pj->npi', l2i, ph) # [6, 65536, 4]:6个相机 × 所有点
d = q[..., 2]
uv = q[..., :2] / np.clip(d, 1e-5, None)[..., None]
valid = (d > 1e-5) & (0<u<W) & (0<v<H) # [6, 65536]
valid = valid.reshape(6, P, 4) # [6, 16384, 4] 拆回 (格子, 高度)
cov = valid.any(axis=2) # [6, 16384] 4个高度里任意一个有效就算覆盖
形状变化(重点):
coords [16384,2] → pts [65536,3] → ph [65536,4] → q [6,65536,4]
→ valid [6,65536] → reshape [6,16384,4] → any(高度) → cov [6,16384]
reshape(6, P, 4) 能把数据正确拆开,前提是 np.repeat 让同一格子的 4 个高度紧挨着。如果把 repeat 和 tile 用反了,格子和高度就会对不上。脚本里有一行自检,会把 STEP 3 那个格子的结果和 cov 里的对应值进行比较:
自检: STEP 3 那个格子的 cov[:, 5062] = [1 0 0 0 0 0] ← 只有 FRONT,和表格一致
为什么是 any:4 个高度里只要有一个能被相机看到,这个格子就能从该相机取到特征。贴近自车的格子,地面点可能在相机视野下方之外,但 z=4 那个高点仍然能看到。所以你图里自车两侧的白色盲区只有很窄的一条。
STEP 5:上色(看 step5_coverage.png,从左到右 4 个阶段)
rgb = np.ones((P, 3)) # 5a 全白
for n in range(6):
rgb[cov[n]] = np.array(CMAP(n)[:3])*0.45 + 0.55 # 5b 每个相机涂自己的浅色
# 后涂的会盖住先涂的
overlap = cov.sum(0) >= 2
rgb[overlap] *= 0.75 # 5c 两个以上相机都能看到的格子压暗 25%
cov_img = rgb.reshape(128, 128, 3) # 5d [16384,3] → [128,128,3]
ax.imshow(cov_img, extent=[-pc, pc, -pc, pc])
*0.45 + 0.55:把颜色和白色按 45%/55% 混合,得到浅色,这样绿框叠上去还看得清。reshape(128,128,3):因为 coords 是按行展开的,reshape 后cov_img[行, 列]正好对应第 (行, 列) 个格子。imshow默认origin='upper':第 0 行画在最上面。配合extent,第 0 行显示在 x=+51.2(前方),第 0 列显示在 y=-51.2(左边)。这和_make_coords的约定完全一致,所以画出来的图上方就是车头方向。
最后叠加 GT 框,有一个容易踩的坑:
ax.add_patch(Polygon(c[:, ::-1], ...)) # c 的列是 (x, y),画图时要传 (y, x)
画布的横轴是 y(右),纵轴是 x(前),所以画任何自车系的点都要把顺序反过来。如果忘了 [:, ::-1],整张图会沿对角线镜像。
4. Part B:相机图上的 3D 框是怎么画出来的
STEP 6:在 BEV 平面上算出 4 个角点(看 step6_box_bev.png)
local = [[ l/2, w/2], # 角点0:前右
[ l/2, -w/2], # 角点1:前左
[-l/2, -w/2], # 角点2:后左
[-l/2, w/2]] # 角点3:后右
R = [[cos, -sin],
[sin, cos]]
world = local @ R.T + [x, y]
分三步,对应图里的 6a、6b、6c:
- 6a 在框自己的坐标系里摆 4 个角:车头朝 +x,中心在原点。这样摆的好处是,不管车朝哪个方向,4 个角的写法都一样,只依赖长和宽。
- 6b 旋转 yaw 角度。
local @ R.T等价于对每个角点做R @ 角点。在 x前/y右 的坐标系里,yaw>0 表示车头往右转。 - 6c 平移到框中心 (x, y),就得到了自车系下的真实坐标。
脚本的示例框 yaw=0,所以旋转那一步没有变化。你可以用 --box 选一个斜着的框,比如合成数据里的 --box 2(yaw=90°),就能看到旋转的效果。
STEP 7:加上高度,变成 8 个 3D 角点(看 step7_box_3d.png)
z0 = z - h/2 # 标注里的 z 是框中心高度 → 先算出底面高度
c3 = vstack([ [world, z0], # 角点 0-3:底面
[world, z0 + h] ]) # 角点 4-7:顶面(和底面一一对应在正上方)
编号规则:k 和 k+4 是同一根竖棱的下端和上端;0、1、4、5 在车头。
如果你的数据集里 z 表示底面高度,就加 --z-bottom。判断方法:如果相机图上的框整体比车低半个车身(下半截埋在地下),就说明 z 是底面高度,而代码按中心高度处理了。你截图里的框贴合得很好,说明当前的约定是对的。
STEP 8:投影到相机并连线(看 step8_box_in_cams.png)
EDGES = [(0,1),(1,2),(2,3),(3,0), # 底面 4 条
(4,5),(5,6),(6,7),(7,4), # 顶面 4 条
(0,4),(1,5),(2,6),(3,7), # 竖棱 4 条
(0,5),(1,4)] # 车头面的 × ← 用来看朝向
uv, d = project(c3, l2i[n]) # 8 个角点 → 8 个 (u, v, d)
if not in_image(uv, d, W, H, dmin=1.0).any():
跳过这个相机 # 规则①:没有任何角点在图内
for i, j in EDGES:
if d[i] > 1.0 and d[j] > 1.0: # 规则②:线的两端都在相机前方 1m 以外
ax.plot(uv[[i,j],0], uv[[i,j],1])
ax.set_xlim(0, W); ax.set_ylim(H, 0) # 规则③:超出图像的部分自动裁掉
脚本打印的数据把这三条规则体现得很清楚:
[FRONT] → 画(8/8 个角点在图像内)
角点0: d= 12.75 u= 335.7 v= 168.1 ✓ ← 车头离得远(12.75m)
角点2: d= 8.25 u= 322.9 v= 190.0 ✓ ← 车尾离得近(8.25m),所以在图上更靠下、更大
[FRONT_RIGHT] → 画(2/8 个角点在图像内) ← 只露出车尾一角,也要画(截断的框)
角点0: d= 10.66 u= -26.3 ... 图外
角点3: d= 8.08 u= 39.7 ... ✓
[FRONT_LEFT] → 不画
角点3: d= 0.79 u= 4167.1 ... 背后 ← d<1m,u 飞到了 4167
规则②为什么是 1 米:最后一行就是例子。当 d 接近 0 时,u = (u·d)/d 会变得极大,连出来的线会横穿整个画面。你上一次截图里 CAM4、CAM5 上那几条长斜线就是这个原因,新版 vis_bev.py 已经把阈值改成了 1 米。
车头的 × 有什么用:在 FRONT 图里,× 出现在离我们更远、更小的那一面,说明这辆车的车头朝前,和我们同向行驶。我们看到的是它的车尾。如果某辆同向车的 × 出现在靠近我们的那一面,说明 yaw 差了 180°,标注或 yaw 的约定有问题。这是检查朝向最直接的方法。
5. 结合你的两张截图,把整个过程串起来
截图 1:覆盖图
- 6 个扇区的颜色和图例一致:FRONT=蓝、FRONT_LEFT=橙、FRONT_RIGHT=绿、BACK=红、BACK_LEFT=紫、BACK_RIGHT=棕。这说明
--cam-names的顺序填对了。 - 深色的窄楔形是相邻相机的重叠区(STEP 5 的
*0.75压暗)。 - 自车左右两侧有很窄的白色盲区,占 0.3%,原因见 STEP 4 的
any。
截图 2:相机图(用 BEV 位置和相机图一一对照)
| BEV 上的框 | 落在哪个扇区 | 相机图上的对应位置 |
|---|---|---|
| 正前方一列框(y≈0~5,x≈5~30) | 蓝色 FRONT | FRONT 图里正前方的白车,以及右侧近处的黑车 |
| 左前方的框(y≈-5,x≈20~30) | 橙色和蓝色交界 | FRONT_LEFT 图里的蓝色轿车 |
| 左后方 (y≈-38, x≈-13) | 紫色 BACK_LEFT | BACK_LEFT 图里左侧的车 |
| 正后方一列框(x≈-10~-40) | 红色 BACK | BACK 图里同车道后面的面包车和远处的几辆车 |
一个框在 BEV 上落在哪个颜色的扇区里,它就出现在对应颜色的相机画面中。两边用的是同一个 lidar2img,所以位置能对上。如果有对不上的情况(比如 BEV 上在右边,相机图里却出现在左边),那就是 lidar2img 有错。
另外两个细节:
- FRONT_RIGHT 和 BACK_RIGHT 里的红线是模型的预测框(分数 ≥ 0.3),不是 GT。它们集中在自车右侧近处,说明模型目前在这一带有一些误检。
- BACK_RIGHT 右边缘的绿色竖线,是一辆贴近自车的车,只有一根竖棱进入了画面(STEP 8 的规则①:一个角点在图内就会画)。
6. 怎么打断点,逐步看执行过程
方法 1:pdb(终端里直接用)
python learn_projection.py --root ../dataset_v4 --frame 8 --pause
每个 STEP 结束后会自动停下,提示符变成 (Pdb)。常用命令:
| 命令 | 作用 | 示例 |
|---|---|---|
p 表达式 |
打印 | p l2i.shape、p coords[:3] |
pp 变量 |
格式化打印 | pp cams[0] |
p 任意代码 |
现场计算 | p l2i[0] @ np.r_[pillar[1], 1](手动投影一个点) |
l |
显示当前位置附近的代码 | |
n |
执行下一行 | |
c |
继续执行,到下一个断点停下 | |
interact |
进入完整的 Python 交互环境(Ctrl+D 退出) | 可以随意画图、试验 |
q |
退出 |
建议在每个断点试试这些:
# 【断点 3】手动验证 2.2 节的手算
p l2i[0] @ np.r_[pillar[1], 1] # 应该得到 [5765.6, 2848.4, 18.25, 1]
# 【断点 4】看一个格子在 6 个相机 × 4 个高度下的有效性
p valid[:, idx] # [6,4] 的 True/False 矩阵
p cov.sum(0).max() # 一个格子最多被几个相机同时看到
# 【断点 6】自己改 yaw 看角点怎么变
p local @ np.array([[0,-1],[1,0]]).T + [x, y] # yaw=90° 时的角点
# 【断点 8】看每个角点投到 FRONT 后的位置
p project(c3, l2i[0])
方法 2:VS Code 图形化断点(推荐,更直观)
你已经在用 VS Code Remote-SSH 连服务器了:
- 左下角选择 Python 解释器,选 conda 环境
ad。 - 在
2.3/.vscode/launch.json里写:
{
"version": "0.2.0",
"configurations": [
{
"name": "learn_projection (真实数据)",
"type": "debugpy",
"request": "launch",
"program": "${workspaceFolder}/learn_projection.py",
"args": ["--root", "../dataset_v4", "--split", "val", "--frame", "8"],
"cwd": "${workspaceFolder}",
"console": "integratedTerminal",
"justMyCode": true
},
{
"name": "vis_bev",
"type": "debugpy",
"request": "launch",
"program": "${workspaceFolder}/vis_bev.py",
"args": ["--ckpt", "./work_dir/best.pth", "--root", "../dataset_v4", "--num", "1"],
"cwd": "${workspaceFolder}",
"console": "integratedTerminal"
}
]
}
(${workspaceFolder} 要指向 2.3 这个目录。如果你打开的是上级目录,把路径改成 ${workspaceFolder}/courses/M2/2.3/...)
- 在代码里搜索
【断点,在对应行号左侧点一下,打上红点。 - 按 F5 运行。程序停下后,左侧"变量"面板可以展开查看所有数组,下方"调试控制台"可以输入表达式,作用和 pdb 的
p一样。
理解了之后,回到 vis_bev.py 的对应位置
| learn_projection.py | vis_bev.py 中对应的代码 | 建议打断点的位置 |
|---|---|---|
| STEP 3-4 | camera_coverage() |
cov[n] \|= ... 那一行 |
| STEP 5 | render_frame() 中 # ---- ① 相机覆盖 + GT ---- 那一段 |
ax.imshow(rgb.reshape(...)) |
| STEP 6 | box_corners_bev() |
return local @ R.T + ... |
| STEP 7 | box_corners_3d() |
return np.vstack(...) |
| STEP 8 | render_frame() 中 # ---- 相机图 ---- 那一段 |
uv, d = project(...) |
两个文件的逻辑是一模一样的。learn_projection.py 只是把这些步骤拆开,多打印了中间结果。
7. 动手练习(用来检验自己是不是真的懂了)
每个练习改一处代码,先预测会发生什么,再运行验证:
--cell 0 15(自车正右方 15 米):会被哪些相机看到?是不是在重叠区?- 把 STEP 6 的
R.T改成R(等于 yaw 取反):斜着的框会怎么变?相机图上的 × 会跑到哪一面? - 把
A_BODY2CV第二行的-1改成1:相机图里的框会出现在哪里?(提示:天和地会颠倒) - 把 STEP 4 的
np.repeat和np.tile对调:自检那一行会输出什么?覆盖图会变成什么样? - 把
zs改成只有[0.0](只取地面一个点):自车周围的白色盲区会变大还是变小?为什么?这对 SCA 意味着什么? - 把
dmin=1.0改成1e-5:近处的车会出现什么样的线?
小结
- 核心只有一个公式:
[u·d, v·d, d] = lidar2img @ [x, y, z, 1],然后除以 d。覆盖图和 3D 框都是在用它。 - lidar2img = 内参 K × 换轴 A × 外参。STEP 1 可以从矩阵反推出相机的安装位置和朝向,是检查数据最快的方法。
- 覆盖图:格子 → 4 个高度的柱子点 → 投影 → 判断是否在相机前方并落在图内 → 在高度上取
any→ 按相机上色,重叠区压暗 → reshape 成 128×128。 - 3D 框:在框坐标系摆 4 个角 → 旋转 yaw → 平移 → 加上底面、顶面高度得到 8 个点 → 投影 → 连 14 条线(只要有一个角点在图内就画,线两端都要在相机前方 1 米以外)。
- 画 BEV 图时要注意轴的顺序:横轴是 y、纵轴是 x,所以要写成
plot(y, x)或者c[:, ::-1]。 - 车头面上的 × 是检查朝向的标志,覆盖图的颜色和相机名对得上则说明外参是对的。
建议的顺序是:先用合成数据跑一遍 --pause,手动验证 2.2 节的计算;再用 --root ../dataset_v4 --frame 8 跑你的真实数据,把 STEP 1 的那张表发给我,我帮你确认一下你的相机外参是否正确。
研究数据转换
conda activate ad
cd ~/carla/work/courses/M2/2.3 # 把 learn_projection.py 放到这里
# ① 合成数据(先用它理解原理,结果和上面的图一样)
python learn_projection.py --out ./learn_syn
# ② 你的真实数据(换成你截图里那一帧)
python learn_projection.py --root ../dataset_v4 --split val --frame 8 --out ./learn_real
# ③ 每一步都停下来,看变量
python learn_projection.py --pause
为者常成,行者常至
自由转载-非商用-非衍生-保持署名(创意共享3.0许可证)