# Lattice Planner实战：如何在自动驾驶中实现高效避障与跟车（附Python代码示例）
如果你正在为自动驾驶车辆的局部轨迹规划寻找一个既灵活又可靠的方案，那么Lattice Planner很可能已经进入了你的视野。这个算法不像传统路径规划那样只关心“从A到B”，它更擅长处理动态环境下的即时决策——比如前方突然出现一个慢车，你是减速跟随，还是果断变道超车？又或者一个行人突然闯入车道，车辆如何在极短时间内规划出一条既安全又舒适的避障轨迹？Lattice Planner的核心魅力，就在于它将复杂的驾驶行为决策，巧妙地转化为了一个在**采样空间**中寻找**最优解**的数学问题。
对于算法工程师和研究者而言，理解Lattice Planner的原理是一回事，但真正让它跑起来，在仿真甚至实车中看到它流畅地跟车、避障，则是另一回事。市面上很多资料要么过于理论，堆砌公式让人望而生畏；要么过于简化，只给个概念，离落地还差十万八千里。这篇文章的目的，就是填补这个鸿沟。我们将绕过繁琐的公式推导，直接从**实际应用场景**切入，手把手带你用Python构建一个简化但功能完整的Lattice Planner，重点攻克**高效避障**和**平稳跟车**这两个核心挑战。我会分享在调整代价函数参数、设计采样策略时踩过的坑，以及如何通过代码直观地看到不同参数对最终轨迹选择的影响。无论你是想快速验证想法，还是为你的自动驾驶项目寻找一个可靠的规划模块，这里都有你需要的干货。
## 1. 理解Lattice Planner的核心：在Frenét坐标系下思考
在深入代码之前，我们必须建立一个正确的思维框架：为什么Lattice Planner通常在Frenét坐标系下工作？想象一下你在一条弯曲的高速公路上行驶。在标准的笛卡尔坐标系（X-Y平面）里，描述你的位置和道路中心线的关系是件麻烦事，因为道路本身是弯曲的。而Frenét坐标系则巧妙地以道路中心线为参考，将问题分解为两个相对独立的方向：**纵向**（沿着参考线方向，记为`s`）和**横向**（垂直于参考线方向，记为`d`或`l`）。
这种分解带来了巨大的便利。车辆的纵向运动主要对应速度控制（加速、减速、巡航），而横向运动则对应路径选择（车道保持、换道）。在Frenét坐标系下，规划问题可以近似解耦为：
* **纵向轨迹规划**：决定未来一段时间内，车辆沿道路方向应该走多远、以多快的速度行驶。
* **横向轨迹规划**：决定未来一段时间内，车辆相对于道路中心线的横向偏移是多少。
这种解耦大大降低了采样空间的维度。Lattice Planner的工作流程，本质上就是在纵向和横向上分别采样一系列候选的终端状态，然后用多项式（通常是五次多项式连接横向状态，四次多项式连接纵向状态）生成连接当前状态与每个终端状态的平滑轨迹，最后通过一个精心设计的**代价函数**，从所有候选轨迹中挑选出最优的一条。
> **提示**：Frenét坐标系并非万能。它的一个关键假设是参考线（道路中心线）的曲率变化平缓。在曲率极大的急弯或交叉路口，Frenét坐标系的精度会下降，可能需要特殊处理或切换规划方法。
为了更直观地理解采样空间，我们可以看下面这个简化的参数表示例，它展示了一次规划循环中可能采样的维度：
| 采样维度 | 物理意义 | 典型采样值示例 | 影响的主要行为 |
| :--- | :--- | :--- | :--- |
| **横向偏移 (d)** | 相对于参考线的横向位置 | [-1.0m, 0.0m, 1.0m] | 车道保持、换道、避障 |
| **纵向目标速度 (s_dot)** | 规划周期末的期望速度 | [5m/s, 10m/s, 15m/s] | 跟车、巡航、停车 |
| **规划时间 (T)** | 轨迹覆盖的时间长度 | [2.0s, 3.0s, 4.0s] | 决策的前瞻性、紧急程度 |
在实际代码中，我们会对这些维度进行循环嵌套采样，生成 `len(d_samples) * len(s_dot_samples) * len(T_samples)` 条候选轨迹。接下来，我们就从零开始构建这个采样与评估的核心循环。
## 2. 构建基础：Python实现轨迹采样与生成
让我们暂时抛开复杂的坐标系转换，先聚焦于轨迹生成的核心——多项式插值。假设我们已经有了在Frenét坐标系下的起始状态和目标状态，如何生成一条平滑的轨迹？这里就需要用到**五次多项式**（横向）和**四次多项式**（纵向）。
为什么是五次和四次？因为我们需要满足边界条件。对于横向轨迹，我们通常约束起始点和终点的位置、速度、加速度（共6个条件），因此需要5阶多项式（6个系数）。对于纵向轨迹，在巡航或跟车场景下，我们可能不严格约束终点的位置，只约束其速度和加速度（共5个条件），因此4阶多项式就够了。
下面是一个用Python实现的五次多项式类，它可以根据给定的起点和终点状态（位置、速度、加速度）以及总时间T，计算出多项式系数，并能评估任意时刻t的位置及其导数。
```python
import numpy as np
class QuinticPolynomial:
"""五次多项式轨迹生成器 (用于横向规划)"""
def __init__(self, xs, vxs, axs, xe, vxe, axe, T):
"""
初始化，计算五次多项式系数
参数:
xs, vxs, axs: 起始状态 (位置, 速度, 加速度)
xe, vxe, axe: 终止状态 (位置, 速度, 加速度)
T: 运动时间
"""
self.xs = xs
self.vxs = vxs
self.axs = axs
self.xe = xe
self.vxe = vxe
self.axe = axe
self.T = T
# 计算五次多项式系数: x(t) = a0 + a1*t + a2*t^2 + a3*t^3 + a4*t^4 + a5*t^5
# 通过解线性方程组得到系数
self.a0 = xs
self.a1 = vxs
self.a2 = axs / 2.0
A = np.array([
[T**3, T**4, T**5],
[3*T**2, 4*T**3, 5*T**4],
[6*T, 12*T**2, 20*T**3]
])
b = np.array([
xe - self.a0 - self.a1*T - self.a2*T**2,
vxe - self.a1 - 2*self.a2*T,
axe - 2*self.a2
])
x = np.linalg.solve(A, b)
self.a3 = x[0]
self.a4 = x[1]
self.a5 = x[2]
def calc_point(self, t):
"""计算时间t对应的位置"""
xt = self.a0 + self.a1*t + self.a2*t**2 + self.a3*t**3 + self.a4*t**4 + self.a5*t**5
return xt
def calc_first_derivative(self, t):
"""计算时间t对应的速度 (一阶导)"""
xt = self.a1 + 2*self.a2*t + 3*self.a3*t**2 + 4*self.a4*t**3 + 5*self.a5*t**4
return xt
def calc_second_derivative(self, t):
"""计算时间t对应的加速度 (二阶导)"""
xt = 2*self.a2 + 6*self.a3*t + 12*self.a4*t**2 + 20*self.a5*t**3
return xt
def calc_third_derivative(self, t):
"""计算时间t对应的加加速度 (Jerk, 三阶导)"""
xt = 6*self.a3 + 24*self.a4*t + 60*self.a5*t**2
return xt
```
有了这个基础工具，我们就可以实现Lattice Planner最核心的采样函数了。下面的 `calc_frenet_paths` 函数展示了如何对横向偏移、纵向目标速度和规划时间进行三重循环采样，生成一簇候选轨迹。
```python
def calc_frenet_paths(c_d, c_d_d, c_d_dd, c_speed, s0, config):
"""
在Frenét空间采样生成候选轨迹
参数:
c_d, c_d_d, c_d_dd: 当前横向状态 (位置, 速度, 加速度)
c_speed: 当前纵向速度
s0: 当前纵向位置
config: 包含采样参数的配置字典
返回:
候选轨迹列表
"""
frenet_paths = []
# 横向采样: 在道路宽度范围内采样目标横向偏移
for di in np.arange(-config.MAX_ROAD_WIDTH, config.MAX_ROAD_WIDTH + config.D_ROAD_W, config.D_ROAD_W):
# 规划时间采样
for Ti in np.arange(config.MIN_T, config.MAX_T + config.DT, config.DT):
# 生成横向轨迹 (五次多项式)
lat_qp = QuinticPolynomial(c_d, c_d_d, c_d_dd, di, 0.0, 0.0, Ti)
fp = FrenetPath()
# 离散化时间，计算横向轨迹点
for t in np.arange(0.0, Ti + config.DT, config.DT):
fp.t.append(t)
fp.d.append(lat_qp.calc_point(t))
fp.d_d.append(lat_qp.calc_first_derivative(t))
fp.d_dd.append(lat_qp.calc_second_derivative(t))
fp.d_ddd.append(lat_qp.calc_third_derivative(t))
# 纵向速度采样
for tv in np.arange(config.TARGET_SPEED - config.D_T_S*config.N_S_SAMPLE,
config.TARGET_SPEED + config.D_T_S*config.N_S_SAMPLE + config.D_T_S,
config.D_T_S):
fp_bot = fp.copy() # 复制横向轨迹基础
# 生成纵向轨迹 (四次多项式，这里用简化版，假设终点加速度为0)
# 注意: 完整实现应使用QuarticPolynomial类
lon_qp = QuarticPolynomial(s0, c_speed, 0.0, tv, 0.0, Ti)
fp_bot.s_d = []
fp_bot.s_dd = []
fp_bot.s_ddd = []
for t in fp.t:
fp_bot.s.append(lon_qp.calc_point(t))
fp_bot.s_d.append(lon_qp.calc_first_derivative(t))
fp_bot.s_dd.append(lon_qp.calc_second_derivative(t))
fp_bot.s_ddd.append(lon_qp.calc_third_derivative(t))
# 计算轨迹的代价 (暂未实现)
fp_bot.cd = 0.0
fp_bot.cv = 0.0
fp_bot.cf = 0.0
frenet_paths.append(fp_bot)
return frenet_paths
```
这里，`FrenetPath` 是一个简单的数据结构类，用于存储一条轨迹的所有信息。`config` 字典则包含了所有可调参数，例如：
```python
class FrenetPath:
def __init__(self):
self.t = [] # 时间序列
self.d = [] # 横向位置序列
self.d_d = [] # 横向速度序列
self.d_dd = [] # 横向加速度序列
self.d_ddd = [] # 横向加加速度序列
self.s = [] # 纵向位置序列
self.s_d = [] # 纵向速度序列 (即车速)
self.s_dd = [] # 纵向加速度序列
self.s_ddd = [] # 纵向加加速度序列
self.cd = 0.0 # 横向轨迹代价
self.cv = 0.0 # 纵向轨迹代价
self.cf = 0.0 # 总代价
```
通过调整 `config` 中的采样步长和范围，你可以在规划质量和计算效率之间进行权衡。采样越密集，找到更优轨迹的可能性越大，但计算量也呈指数级增长。
## 3. 设计代价函数：让车辆学会“选择”与“权衡”
生成了大量候选轨迹后，接下来就是最关键的一步：如何评判哪条轨迹“最好”？这就是**代价函数**的职责。一个设计良好的代价函数，需要综合考量安全性、舒适性、效率和对交通规则的遵守，本质上是在教车辆如何做“权衡”。
在Lattice Planner中，代价函数通常是横向代价和纵向代价的加权和。一条轨迹的总代价 `Cf` 可以表示为：
`Cf = k_lat * Cd + k_lon * Cv`
其中 `Cd` 是横向轨迹代价，`Cv` 是纵向轨迹代价，`k_lat` 和 `k_lon` 是权重系数，用于调整横向和纵向行为的相对重要性。
那么，`Cd` 和 `Cv` 具体包含哪些项呢？根据我的实践经验，一个有效的代价函数至少应包含以下几个核心部分：
* **舒适性代价（Jerk惩罚）**：加加速度（Jerk）的平方积分。Jerk过大意味着速度或加速度变化剧烈，乘客会感到非常不适。这是保证乘坐体验的核心指标。
* **效率代价（时间惩罚）**：规划时间 `T` 本身。在其他条件相同时，车辆倾向于选择能更快到达目标状态的轨迹。
* **目标偏离代价**：轨迹终点状态与理想目标的差距。例如，横向终点偏离期望车道中心的距离平方，纵向终点速度与期望巡航速度的差值平方。
* **安全性代价（碰撞风险）**：这是避障功能的灵魂。通常不是简单的0/1判断，而是根据轨迹上每个点与障碍物的距离，计算一个连续的风险值。距离越近，代价越高。
下面是一个Python实现的代价函数计算示例，它包含了上述部分要素：
```python
def calc_cost(fp, config, ob):
"""
计算单条轨迹的代价
参数:
fp: FrenetPath对象
config: 配置参数
ob: 障碍物列表，每个障碍物为 [s, d] 坐标
返回:
总代价 Cf
"""
# 1. 横向代价 Cd
# Jerk惩罚 (加加速度平方和)
Jp = sum([jp**2 for jp in fp.d_ddd])
# 时间惩罚
time_cost = config.KT * fp.t[-1]
# 横向偏移惩罚 (终点偏离中心线)
lat_offset_cost = config.KD * fp.d[-1]**2
Cd = config.KJ * Jp + time_cost + lat_offset_cost
# 2. 纵向代价 Cv
# Jerk惩罚
Js = sum([js**2 for js in fp.s_ddd])
# 时间惩罚 (与横向共用时间)
time_cost = config.KT * fp.t[-1]
# 速度偏差惩罚 (终点速度与目标速度的差距)
ds = (config.TARGET_SPEED - fp.s_d[-1])
speed_deviation_cost = config.KV * ds**2
Cv = config.KJ * Js + time_cost + speed_deviation_cost
# 3. 碰撞代价 (安全性)
collision_cost = 0.0
for i in range(len(fp.s)):
for obs in ob:
# 计算轨迹点 (fp.s[i], fp.d[i]) 与障碍物 (obs[0], obs[1]) 的欧氏距离 (简化计算)
dist = np.sqrt((fp.s[i] - obs[0])**2 + (fp.d[i] - obs[1])**2)
if dist <= config.ROBOT_RADIUS:
# 如果发生碰撞，赋予一个极大的代价
collision_cost += config.MAX_COLLISION_COST
else:
# 距离越近，代价越高，呈反比关系
collision_cost += config.KOBS / (dist**2)
# 4. 总代价
Cf = config.KLAT * Cd + config.KLON * Cv + collision_cost
return Cf
```
这个函数里用到的权重参数（`KJ`, `KT`, `KD`, `KV`, `KOBS`, `KLAT`, `KLON`）就是你需要反复调试的“魔法数字”。不同的场景需要不同的参数设定：
* **高速公路巡航**：可能更看重 `KV`（速度保持）和舒适性（`KJ`），`KOBS`（避障）权重可以相对较低，因为障碍物较少。
* **城区拥堵跟车**：`KOBS` 和 `KT`（效率）的权重需要提高，同时 `KJ` 也要保持一定值以保证跟车平稳，避免频繁急刹急加速。
* **紧急避障**：需要大幅提高 `KOBS` 的权重，甚至让安全性代价主导整个代价函数，同时可能暂时放松对舒适性（`KJ`）的约束。
> **注意**：碰撞代价的计算这里做了极大简化，直接使用了Frenét坐标下的欧氏距离。在实际应用中，你需要将轨迹点转换回笛卡尔坐标系，并使用车辆的实际轮廓（Footprint）与障碍物进行多边形碰撞检测，这才是准确且安全的做法。
调试这些参数没有银弹，最好的方法就是在你的仿真环境中，针对特定场景（如cut-in、前方静止障碍物等）进行大量测试，观察车辆的行为，并记录下不同参数组合下的表现。一个实用的技巧是使用**参数自动调优工具**（如贝叶斯优化）来搜索较优的参数空间。
## 4. 实战场景一：动态跟车——平滑与安全的博弈
跟车是自动驾驶中最常见也最考验规划器能力的场景之一。理想跟车轨迹需要达成几个看似矛盾的目标：**快速缩小与前车距离**（效率）、**保持安全车距**（安全）、**加速度变化平滑**（舒适）。Lattice Planner如何应对这个挑战？
关键在于纵向采样策略和代价函数的设计。在跟车场景下，纵向采样不再是均匀的目标速度范围，而是需要与前车状态（`s_obs`, `v_obs`）强相关。一种常见的策略是，在ST图（纵向位置-时间图）上，在前车轨迹的“阴影区”上下进行采样。
假设我们感知到前车的位置 `s_obs` 和速度 `v_obs`，我们可以预测其未来轨迹（假设匀速）。那么，我们的纵向采样目标状态 `(s_target, v_target)` 可以这样设计：
```python
def sample_longitudinal_for_following(s0, v0, s_obs, v_obs, config):
"""
为跟车场景生成纵向采样目标
参数:
s0, v0: 自车当前纵向位置和速度
s_obs, v_obs: 前车当前纵向位置和速度
config: 配置
返回:
纵向目标状态列表 [(s_target1, v_target1, T1), ...]
"""
targets = []
# 预测前车在未来一段时间的位置
for T in np.arange(config.MIN_T, config.MAX_T, config.DT):
s_obs_future = s_obs + v_obs * T
# 我们希望保持的安全距离，可以是固定值或基于速度的动态值
desired_gap = config.DESIRED_TIME_HEADWAY * v0 + config.MIN_GAP
# 采样目标位置：在前车后方一个安全距离处
s_target = s_obs_future - desired_gap
# 采样目标速度：接近前车速度，但可以略有不同以实现平缓调整
for v_offset in np.linspace(-1.0, 1.0, 5): # 在目标速度附近小范围采样
v_target = v_obs + v_offset
if v_target < 0:
v_target = 0.0
targets.append((s_target, v_target, T))
return targets
```
在代价函数中，跟车场景需要特别强化以下几项：
1. **相对距离代价**：惩罚轨迹上任何一点与前车距离小于安全阈值的状态。
2. **相对速度代价**：当距离较近时，自车速度应不大于前车速度，避免碰撞风险。
3. **加速度平滑性代价**：比平时更高的权重，因为跟车时频繁的加速减速会让乘客非常难受。
我曾在一个项目中，车辆在低速跟车时总是出现“点头”现象（轻微但频繁的加速减速）。通过日志分析发现，是纵向采样中目标速度的离散点过于稀疏，导致规划器只能在几个离散的速度档位间跳跃。将 `v_offset` 的采样点从3个增加到7个，并略微提高加加速度（Jerk）的代价权重 `KJ`，这个问题就得到了显著改善。
## 5. 实战场景二：静态与动态避障——风险场与轨迹可行性检查
避障是规划器的底线功能。Lattice Planner处理避障主要有两种思路，通常结合使用：
**1. 基于代价函数的软约束（风险场）**
就像前面代价函数示例中的 `collision_cost`，它为靠近障碍物的轨迹点赋予高代价。这就像一个“风险场”，障碍物周围代价升高，规划器自然倾向于选择代价低的区域，即远离障碍物的路径。这种方法计算简单，能生成平滑的绕行轨迹。但它是一种“软”约束，不能绝对保证安全。
**2. 基于碰撞检测的硬约束（可行性检查）**
在计算出所有轨迹的代价并初步排序后，必须对排名靠前的若干条轨迹进行严格的**碰撞检测**。只有通过碰撞检测的轨迹才有资格被最终选择。这是一个“硬”约束，是安全性的最后防线。
碰撞检测需要在笛卡尔坐标系下进行。这意味着我们需要将Frenét轨迹 `(s, d)` 转换回 `(x, y)`。这通常通过查询之前用样条曲线（Cubic Spline）拟合的参考线映射关系来完成。转换后，我们用车辆的外接矩形或多边形，沿着轨迹点依次检查是否与障碍物多边形相交。
下面是一个简化的碰撞检查函数概念：
```python
def check_collision(fp, spline_ref, obstacles_cartesian, vehicle_width, vehicle_length):
"""
检查一条轨迹是否与障碍物碰撞
参数:
fp: FrenetPath轨迹
spline_ref: 参考线样条对象，用于Frenet转Cartesian
obstacles_cartesian: 笛卡尔坐标系下的障碍物列表 [[x1,y1], [x2,y2], ...]
vehicle_width, vehicle_length: 车辆尺寸
返回:
True (安全) 或 False (碰撞)
"""
for i in range(len(fp.s)):
# 1. Frenet 转 Cartesian
x, y = spline_ref.calc_position(fp.s[i]) # 根据参考线计算
# 考虑横向偏移d，计算实际车辆中心位置 (这里简化处理)
yaw_ref = spline_ref.calc_yaw(fp.s[i])
x_center = x + fp.d[i] * np.cos(yaw_ref + np.pi/2) # 横向偏移方向垂直于参考线切线
y_center = y + fp.d[i] * np.sin(yaw_ref + np.pi/2)
# 2. 构建车辆在该位置的轮廓多边形 (矩形简化)
half_w = vehicle_width / 2.0
half_l = vehicle_length / 2.0
corners = [
(x_center + half_l, y_center + half_w),
(x_center + half_l, y_center - half_w),
(x_center - half_l, y_center - half_w),
(x_center - half_l, y_center + half_w)
]
vehicle_polygon = Polygon(corners)
# 3. 与所有障碍物进行多边形相交检测
for obs in obstacles_cartesian:
# 假设障碍物也是矩形，有类似的方法构建多边形
obs_polygon = Polygon(...)
if vehicle_polygon.intersects(obs_polygon):
return False # 发生碰撞
return True # 全程安全
```
对于动态障碍物，情况更复杂。你需要预测障碍物在未来几秒内的轨迹，然后在每个时间步 `t`，检查自车轨迹在 `t` 时刻的位置是否与预测的障碍物位置发生碰撞。这通常需要在速度-时间（ST）图和横向位置-时间（LT）图上进行联合分析，识别出冲突区域并避开。
一个常见的坑是，只考虑了障碍物当前帧的位置，而没有预测其运动。这会导致规划出“恰好”穿过当前障碍物所在位置的轨迹，而下一秒障碍物移动过来就会发生碰撞。**引入哪怕是最简单的匀速预测模型，都能极大提升动态避障的安全性。**
## 6. 性能优化与高级技巧：从能用变好用
当一个基础的Lattice Planner能工作后，接下来就要考虑如何让它更高效、更鲁棒。计算效率是Lattice Planner的一个主要关切点，因为采样数量会随着维度增加而爆炸式增长。
**优化策略1：非均匀采样与自适应采样**
与其在全局进行均匀密集采样，不如根据场景动态调整采样重点。
* **跟车时**：纵向采样集中在前车速度附近，横向采样集中在当前车道中心。
* **换道时**：横向采样集中在当前车道和目标车道中心，纵向采样可以更关注速度匹配。
* **紧急避障时**：横向采样需要更宽的范围以寻找绕行空间，同时可以缩短规划时间 `T` 以进行更短时域的快速决策。
**优化策略2：轨迹剪枝与分层筛选**
在计算完整的代价函数之前，可以先进行一轮快速的可行性筛选，剔除明显不合格的轨迹，例如：
* **运动学约束**：检查轨迹上任何点的曲率是否超过车辆最大转向角对应的最小转弯半径。
* **动力学约束**：检查速度、加速度是否超出车辆物理极限。
* **粗糙碰撞检查**：使用计算量更小的圆形包围盒进行快速碰撞筛查。
```python
def quick_prune(fp, config):
"""快速剪枝，剔除明显不可行的轨迹"""
# 检查最大曲率
max_curvature = max([abs(fp.calc_curvature(i)) for i in range(len(fp.s))]) # 需要实现曲率计算
if max_curvature > config.MAX_CURVATURE:
return True # 需要剪枝
# 检查最大加速度
max_accel = max([abs(a) for a in fp.s_dd])
if max_accel > config.MAX_ACCEL:
return True
# 检查速度范围
if max(fp.s_d) > config.MAX_SPEED or min(fp.s_d) < config.MIN_SPEED:
return True
return False # 保留
```
**优化策略3：代价函数的热启动与记忆**
在连续规划周期之间，车辆状态和环境通常是渐变的。可以利用上一周期的最优轨迹信息来“热启动”当前周期的搜索。例如，可以将上一周期最优轨迹的终点状态，作为当前周期采样的一个高质量起点，或者在其附近进行精细采样。这不仅能加快找到最优解的速度，还能增强轨迹的连续性，减少车辆抖动。
最后，也是最重要的一点：**可视化与调试**。你需要将采样的所有候选轨迹、它们的代价、障碍物、参考线等都实时绘制出来。只有这样，你才能直观地理解规划器为什么做出了某种选择，以及当它做出错误选择时，问题出在采样、代价函数还是碰撞检测上。我习惯在每次测试时，将关键帧的可视化结果和所有参数保存下来，建立案例库，这对于复现问题和迭代算法有巨大帮助。
调试Lattice Planner是一个不断与“权衡”打交道的过程。没有一条轨迹是完美的，你总是在安全、舒适、效率、合规之间寻找当前场景下的最佳平衡点。这个过程充满挑战，但当看到车辆在复杂的仿真环境中流畅自主地行驶时，那种成就感也是无与伦比的。希望本文提供的思路和代码片段，能成为你探索Lattice Planner世界的一块坚实垫脚石。
热门内容
最新推荐
