def generate(scenario_list):
dx = np.array([t.obj_car.displacement_x for t in scenario_list])
dx = np.fabs(dx)
voy = np.array([t.obj_car.velocity_y for t in scenario_list])
voy = np.fabs(voy)
ve = np.array([t.ego_car.velocity_x for t in scenario_list])
vo = np.array([t.obj_car.velocity_x for t in scenario_list])
# 计算速度的最大最小区间
s_max = int(np.max(dx) + 1)
s_min = int(np.min(dx) - 1)
# 当数据量大的时候可以酌情考虑将区间加大，目前设置成5
step = int((s_max - s_min) / 5) + 1
dx_cluster = []
voy_par = []
for i in range(6):
ran_speed = np.where((dx > s_min + i * step) & (dx < s_min +
(i + 1) * step))
if len(ran_speed[0]) > 0:
dx_cluster.append(s_min + i * step + step / 2)
voy_par.append(MathParameter(voy[ran_speed]))
degrees = [1]
colors = ['b']
font = {
'family': 'Times New Roman',
'weight': 'normal',
'size': 15,
}
figure = plt.figure(figsize=(30, 30))
index = 0
# for rv in range(10, 47, 4):
# index += 1
# plt.subplot(3, 3, index)
# 绘制采样点
draw_back(20, ve, dx, voy, figure)
plt.figure(figsize=(30, 30))
for rv in range(10, 41, 10):
for ve in range(60, 19, -10):
index += 1
plt.subplot(4, 5, index)
if ve - rv <= 0:
continue
draw_back2(ve, ve - rv, max(dx), max(voy))
draw(dx, voy, dx_cluster, voy_par, degrees, colors,
'../parameters/dx_voy', 'dx', 'voy')
plt.show()
def fit_time(time, ego_v, relative_v, displacement):
ego_v_cluster = []
relative_v_cluster = []
displacement_cluster = []
time_ego_v_par = []
time_relative_v_par = []
time_displacement_par = []
# g = []
# 计算速度的最大最小区间
s_max = int(np.max(ego_v) + 1)
s_min = int(np.min(ego_v) - 1)
# 当数据量大的时候可以酌情考虑将区间加大，目前设置成5
step = int((s_max - s_min) / 5) + 1
# 本车速度->变道极值时间
# g.append(s_min)
for i in range(6):
ran_speed = np.where((ego_v > s_min + i * step) & (ego_v < s_min +
(i + 1) * step))
if len(ran_speed[0]) > 0:
ego_v_cluster.append(s_min + i * step + step / 2)
time_ego_v_par.append(MathParameter(time[ran_speed]))
# g.append(s_min + (i + 1) * step)
# 计算速度的最大最小区间
s_max = int(np.max(relative_v) + 1)
s_min = int(np.min(relative_v) - 1)
# 当数据量大的时候可以酌情考虑将区间加大，目前设置成5
step = int((s_max - s_min) / 5) + 1
# 本车速度->变道极值时间
for i in range(6):
ran_speed = np.where((relative_v > s_min + i * step)
& (relative_v < s_min + (i + 1) * step))
if len(ran_speed[0]) > 0:
relative_v_cluster.append(s_min + i * step + step / 2)
time_relative_v_par.append(MathParameter(time[ran_speed]))
# 计算速度的最大最小区间
s_max = int(np.max(displacement) + 1)
s_min = int(np.min(displacement) - 1)
# 当数据量大的时候可以酌情考虑将区间加大，目前设置成5
step = int((s_max - s_min) / 5) + 1
# 本车速度->变道极值时间
for i in range(6):
ran_speed = np.where((displacement > s_min + i * step)
& (displacement < s_min + (i + 1) * step))
if len(ran_speed[0]) > 0:
displacement_cluster.append(s_min + i * step + step / 2)
time_displacement_par.append(MathParameter(time[ran_speed]))
degrees = [1]
colors = ['b']
font = {
'family': 'Times New Roman',
'weight': 'normal',
'size': 15,
}
plt.figure(figsize=(20, 20))
# 本车速度-变道时间
plt.subplot(2, 2, 1)
draw(ego_v, time, ego_v_cluster, time_ego_v_par, degrees, colors,
'../parameters/ev_time', 'ego_v', 'time')
# for li in g:
# plt.vlines(li, -6, 12, colors="c", linestyles="dashed")
# 相对速度-变道时间
plt.subplot(2, 2, 2)
draw(relative_v, time, relative_v_cluster, time_relative_v_par,
degrees, colors, '../parameters/rv_time', 'relative_v', 'time')
# 两车距离-变道时间
plt.subplot(2, 2, 3)
draw(displacement, time, displacement_cluster, time_displacement_par,
degrees, colors, '../parameters/dis_time', 'displacement', 'time')
plt.show()
def fit2(ego_v, ego_a, obj_v, obj_a, distance, relative_v):
# 计算速度的最大最小区间
s_max = int(np.max(ego_v) + 1)
s_min = int(np.min(ego_v) - 1)
# 当数据量大的时候可以酌情考虑将区间加大，目前设置成5
step = int((s_max - s_min) / 5) + 1
# 将本车速度分区
speed_cluster = []
obj_speed_cluster = []
relative_speed_cluster = []
distance_cluster = []
y_speed_cluster = []
a_par = []
obj_speed_par = []
obj_a_par = []
distance_par = []
distance_relative_par = []
# 获取每个区域内的最大最小值，遍历区间比拆分区间大一
# 本车速度相关性分析
# 本车速度->本车加速度、目标车速度、距离
for i in range(6):
ran_speed = np.where((ego_v > s_min + i * step) & (ego_v < s_min +
(i + 1) * step))
if len(ran_speed[0]) > 0:
speed_cluster.append(s_min + i * step + step / 2)
a_par.append(MathParameter(ego_a[ran_speed]))
obj_speed_par.append(MathParameter(obj_v[ran_speed]))
distance_par.append(MathParameter(distance[ran_speed]))
# 目标车速度相关性分析
# 目标车速度->目标车加速度
s_max = int(np.max(obj_v) + 1)
s_min = int(np.min(obj_v) - 1)
# 当数据量大的时候可以酌情考虑将区间加大，目前设置成5
step = int((s_max - s_min) / 5) + 1
for i in range(6):
ran_speed = np.where((obj_v > s_min + i * step) & (obj_v < s_min +
(i + 1) * step))
if len(ran_speed[0]) > 1:
obj_speed_cluster.append(s_min + i * step + step / 2)
obj_a_par.append(MathParameter(obj_a[ran_speed]))
# 相对速度相关性分析
# 相对速度->距离
s_max = int(np.max(relative_v) + 1)
s_min = int(np.min(relative_v) - 1)
step = int((s_max - s_min) / 5) + 1
for i in range(6):
ran_speed = np.where((relative_v > s_min + i * step)
& (relative_v < s_min + (i + 1) * step))
if len(ran_speed[0]) > 0:
relative_speed_cluster.append(s_min + i * step + step / 2)
distance_relative_par.append(MathParameter(
distance[ran_speed]))
# 以下是数据拟合部分以及画图部分
# 设置颜色和多项式的阶数
degrees = [1]
colors = ['b']
font = {
'family': 'Times New Roman',
'weight': 'normal',
'size': 15,
}
plt.figure(figsize=(30, 20))
plt.subplot(2, 3, 1)
# 本车速度，本车加速度
draw(ego_v, ego_a, speed_cluster, a_par, degrees, colors,
'../parameters/ev_ea', 'ego-v', 'ego-a')
plt.subplot(2, 3, 2)
# 本车速度，目标车速度
draw(ego_v, obj_v, speed_cluster, obj_speed_par, degrees, colors,
'../parameters/ev_ov', 'ego-v', 'obj-v')
plt.subplot(2, 3, 3)
# 本车速度，距离
draw(ego_v, distance, speed_cluster, distance_par, degrees, colors,
'../parameters/ev_dis', 'ego-v', 'distance')
plt.subplot(2, 3, 4)
# 目标车速度，目标车加速度
draw(obj_v, obj_a, obj_speed_cluster, obj_a_par, degrees, colors,
'../parameters/ov_oa', 'obj-v', 'obj-a')
plt.subplot(2, 3, 5)
# 相对速度, 距离
draw(relative_v, distance, relative_speed_cluster,
distance_relative_par, degrees, colors, '../parameters/rv_dis',
'relative-v', 'distance')
plt.show()
return
def fit(self, ego_v, ego_y_v, distance, relative_v):
# 计算速度的最大最小区间
s_max = int(np.max(ego_v) + 1)
s_min = int(np.min(ego_v) - 1)
# 当数据量大的时候可以酌情考虑将区间加大，目前设置成5
step = int((s_max - s_min) / 5) + 1
# 将本车速度分区
ego_v_cluster = []
# 本车速度-相对速度 ego-v relative-v
ev_rv_par = []
# 本车速度-距离 ego-v distance
ev_dis_par = []
# 本车速度-本车横向速度 ego-v ego-y-v
ev_eyv_par = []
# 获取每个区域内的最大最小值，遍历区间比拆分区间大一
for i in range(6):
ran_speed = np.where((ego_v > s_min + i * step) & (ego_v < s_min +
(i + 1) * step))
if len(ran_speed[0]) > 0:
ego_v_cluster.append(s_min + i * step + step / 2)
ev_rv_par.append(MathParameter(relative_v[ran_speed]))
ev_dis_par.append(MathParameter(distance[ran_speed]))
ev_eyv_par.append(MathParameter(ego_y_v[ran_speed]))
# 计算速度的最大最小区间
s_max = int(np.max(relative_v) + 1)
s_min = int(np.min(relative_v) - 1)
# 当数据量大的时候可以酌情考虑将区间加大，目前设置成5
step = int((s_max - s_min) / 5) + 1
relative_v_cluster = []
# 相对速度-本车速度 relative-v ego-v
rv_ev_par = []
# 相对速度-距离 relative-v distance
rv_dis_par = []
# 相对速度-本车横向速度 relative-v ego-y-v
rv_eyv_par = []
# 获取每个区域内的最大最小值，遍历区间比拆分区间大一
for i in range(6):
ran_speed = np.where((relative_v > s_min + i * step)
& (relative_v < s_min + (i + 1) * step))
if len(ran_speed[0]) > 0:
relative_v_cluster.append(s_min + i * step + step / 2)
rv_ev_par.append(MathParameter(ego_v[ran_speed]))
rv_dis_par.append(MathParameter(distance[ran_speed]))
rv_eyv_par.append(MathParameter(ego_y_v[ran_speed]))
# 计算速度的最大最小区间
s_max = int(np.max(distance) + 1)
s_min = int(np.min(distance) - 1)
# 当数据量大的时候可以酌情考虑将区间加大，目前设置成5
step = int((s_max - s_min) / 5) + 1
distance_cluster = []
# 距离-本车速度 distance ego-v
dis_ev_par = []
# 距离-相对速度 distance relative-v
dis_rv_par = []
# 距离-本车横向速度 distance ego-y-v
dis_eyv_par = []
# 获取每个区域内的最大最小值，遍历区间比拆分区间大一
for i in range(6):
ran_speed = np.where((distance > s_min + i * step)
& (distance < s_min + (i + 1) * step))
if len(ran_speed[0]) > 0:
distance_cluster.append(s_min + i * step + step / 2)
dis_ev_par.append(MathParameter(ego_v[ran_speed]))
dis_rv_par.append(MathParameter(relative_v[ran_speed]))
dis_eyv_par.append(MathParameter(ego_y_v[ran_speed]))
# 计算速度的最大最小区间
s_max = int(np.max(ego_y_v) + 1)
s_min = int(np.min(ego_y_v) - 1)
# 当数据量大的时候可以酌情考虑将区间加大，目前设置成5
step = int((s_max - s_min) / 5) + 1
ego_y_v_cluster = []
# 本车横向速度-本车速度 ego-y-v ego-v
eyv_ev_par = []
# 本车横向速度-相对速度 ego-y-v relative-v
eyv_rv_par = []
# 本车横向速度-距离 ego-y-v distance
eyv_dis_par = []
# 获取每个区域内的最大最小值，遍历区间比拆分区间大一
for i in range(6):
ran_speed = np.where((ego_y_v > s_min + i * step)
& (ego_y_v < s_min + (i + 1) * step))
if len(ran_speed[0]) > 0:
ego_y_v_cluster.append(s_min + i * step + step / 2)
eyv_ev_par.append(MathParameter(ego_v[ran_speed]))
eyv_rv_par.append(MathParameter(relative_v[ran_speed]))
eyv_dis_par.append(MathParameter(distance[ran_speed]))
# 以下是数据拟合部分以及画图部分
# 设置颜色和多项式的阶数
degrees = [1]
colors = ['b']
font = {
'family': 'Times New Roman',
'weight': 'normal',
'size': 15,
}
plt.figure(figsize=(20, 20))
plt.subplot(4, 4, 1)
plt.subplot(4, 4, 2)
draw(ego_v, relative_v, ego_v_cluster, ev_rv_par, degrees, colors,
'../parameters/ev_rv', 'ego-v', 'relative_v')
plt.subplot(443)
draw(ego_v, distance, ego_v_cluster, ev_dis_par, degrees, colors,
'../parameters/ev_dis', 'ego-v', 'distance')
plt.subplot(444)
draw(ego_v, ego_y_v, ego_v_cluster, ev_eyv_par, degrees, colors,
'../parameters/ev_eyv', 'ego-v', 'ego-y-v')
plt.subplot(445)
draw(relative_v, ego_v, relative_v_cluster, rv_ev_par, degrees, colors,
'../parameters/rv_ev', 'relative_v', 'ego-v')
plt.subplot(447)
draw(relative_v, distance, relative_v_cluster, rv_dis_par, degrees,
colors, '../parameters/rv_dis', 'relative_v', 'distance')
plt.subplot(448)
draw(relative_v, ego_y_v, relative_v_cluster, rv_eyv_par, degrees,
colors, '../parameters/rv_e_y_v', 'relative_v', 'ego-y-v')
plt.subplot(449)
draw(distance, ego_v, distance_cluster, dis_ev_par, degrees, colors,
'../parameters/dis_ev', 'distance', 'ego-v')
plt.subplot(4, 4, 10)
draw(distance, relative_v, distance_cluster, dis_rv_par, degrees,
colors, '../parameters/dis_rv', 'distance', 'relative_v')
plt.subplot(4, 4, 12)
draw(distance, ego_y_v, distance_cluster, dis_eyv_par, degrees, colors,
'../parameters/dis_eyv', 'distance', 'ego_y_v')
plt.subplot(4, 4, 13)
draw(ego_y_v, ego_v, ego_y_v_cluster, eyv_ev_par, degrees, colors,
'../parameters/eyv_ev', 'ego_y_v', 'ego-v')
plt.subplot(4, 4, 14)
draw(ego_y_v, relative_v, ego_y_v_cluster, eyv_rv_par, degrees, colors,
'../parameters/eyv_rv', 'ego_y_v', 'relative_v')
plt.subplot(4, 4, 15)
draw(ego_y_v, distance, ego_y_v_cluster, eyv_dis_par, degrees, colors,
'../parameters/eyv_dis', 'ego_y_v', 'distance')
plt.show()
return