自动驾驶-M2 感知与 BEV-2.3.4 BEVFormer 训练实战代码-相机覆盖 +GT 框

本节做一个重要的技术决策:不用官方仓库,自己实现精简版—— 理由在下面,这不是偷懒,是在你的硬件上唯一正确的选择。学习课程 端到端自动驾驶实战 | zhijia.dev

file

这个 图 相机覆盖+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:

  1. 6a 在框自己的坐标系里摆 4 个角:车头朝 +x,中心在原点。这样摆的好处是,不管车朝哪个方向,4 个角的写法都一样,只依赖长和宽。
  2. 6b 旋转 yaw 角度。local @ R.T 等价于对每个角点做 R @ 角点。在 x前/y右 的坐标系里,yaw>0 表示车头往右转。
  3. 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 连服务器了:

  1. 左下角选择 Python 解释器,选 conda 环境 ad。
  2. 在 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/...)

  1. 在代码里搜索 【断点,在对应行号左侧点一下,打上红点。
  2. 按 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. 动手练习(用来检验自己是不是真的懂了)

每个练习改一处代码,先预测会发生什么,再运行验证:

  1. --cell 0 15(自车正右方 15 米):会被哪些相机看到?是不是在重叠区?
  2. 把 STEP 6 的 R.T 改成 R(等于 yaw 取反):斜着的框会怎么变?相机图上的 × 会跑到哪一面?
  3. 把 A_BODY2CV 第二行的 -1 改成 1:相机图里的框会出现在哪里?(提示:天和地会颠倒)
  4. 把 STEP 4 的 np.repeat 和 np.tile 对调:自检那一行会输出什么?覆盖图会变成什么样?
  5. 把 zs 改成只有 [0.0](只取地面一个点):自车周围的白色盲区会变大还是变小?为什么?这对 SCA 意味着什么?
  6. 把 dmin=1.0 改成 1e-5:近处的车会出现什么样的线?

小结

  1. 核心只有一个公式:[u·d, v·d, d] = lidar2img @ [x, y, z, 1],然后除以 d。覆盖图和 3D 框都是在用它。
  2. lidar2img = 内参 K × 换轴 A × 外参。STEP 1 可以从矩阵反推出相机的安装位置和朝向,是检查数据最快的方法。
  3. 覆盖图:格子 → 4 个高度的柱子点 → 投影 → 判断是否在相机前方并落在图内 → 在高度上取 any → 按相机上色,重叠区压暗 → reshape 成 128×128。
  4. 3D 框:在框坐标系摆 4 个角 → 旋转 yaw → 平移 → 加上底面、顶面高度得到 8 个点 → 投影 → 连 14 条线(只要有一个角点在图内就画,线两端都要在相机前方 1 米以外)。
  5. 画 BEV 图时要注意轴的顺序:横轴是 y、纵轴是 x,所以要写成 plot(y, x) 或者 c[:, ::-1]。
  6. 车头面上的 × 是检查朝向的标志,覆盖图的颜色和相机名对得上则说明外参是对的。

建议的顺序是:先用合成数据跑一遍 --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

为者常成,行者常至