def calc_visibility_and_z_range(self, host_model, Z_ranges):
z_ranges_list = list()
visibilities = list()
for i, lane_model in enumerate(self.lane_models):
visibility = None
model_Z_range = np.asarray([0, 1000])
dist2host_0 = abs(host_model.Z2X(0) - lane_model.Z2X(0))
dist2host_100 = abs(host_model.Z2X(100) - lane_model.Z2X(100))
if (dist2host_0 < 6) and (dist2host_100 < 6):
visibility = get_rand_out_of_list_item(
["visible", 'not_visible'], objects_weights=[0.99, 0.01])
elif (dist2host_0 < 6) and (dist2host_100 >
6): # split lane I'd assume
visibility = get_rand_out_of_list_item(
["barely_visible_in_dist", 'not_visible'],
objects_weights=[0.9, 0.1])
elif (dist2host_0 > 6) and (dist2host_100 < 6): # merge
visibility = get_rand_out_of_list_item(
["barely_visible_in_near", 'not_visible'],
objects_weights=[0.9, 0.1])
elif (dist2host_0 > 6) and (dist2host_100 > 6):
visibility = get_rand_out_of_list_item(
["barely_visible", 'not_visible'],
objects_weights=[0.1, 0.9])
if visibility == "not_visible":
z_ranges_list.append(np.asarray([0, 0]))
continue
elif visibility == "barely_visible_in_dist":
model_Z_range = np.stack(
(get_rand_range(0, 20), get_rand_range(50, 100))).T
elif visibility == "barely_visible_in_near":
model_Z_range = np.stack(
(get_rand_range(10, 60), get_rand_range(80, 150))).T
elif visibility == "barely_visible":
model_Z_range = np.stack(
(get_rand_range(30, 60), get_rand_range(60, 90))).T
elif visibility == "visible":
model_Z_range = Z_ranges[i]
model_Z_range = np.asarray([
max(model_Z_range[0], Z_ranges[i][0]),
min(model_Z_range[1], Z_ranges[i][1])
])
z_ranges_list.append(model_Z_range)
visibilities.append(visibility)
return z_ranges_list, visibilities
def __init__(self, num_lanes):
self.num_lanes = num_lanes
num_vehicles_per_lane_av = random.randint(0, 5)
num_vehicles_per_lane_range = [
max(0, num_vehicles_per_lane_av - 2), num_vehicles_per_lane_av + 2
]
self.num_vehicles_per_lane = get_rand_int(
num_vehicles_per_lane_range[0], num_vehicles_per_lane_range[1],
num_lanes)
self.total_vehicles_num = sum(self.num_vehicles_per_lane)
vehicles_distances = get_rand_range(10, 150, self.total_vehicles_num)
vehicles_yaw_angle_drift = get_rand_range(10, 200,
self.total_vehicles_num)
vehicle_classes = get_rand_out_of_list_item(
["mini", "sedan", "suv", "truck", "bus"],
num_items=self.total_vehicles_num,
objects_weights=[0.07, 0.4, 0.4, 0.07, 0.06])
positions_in_lane = get_rand_range(-0.5, 0.5, self.total_vehicles_num)
vehicles_sizes = self.init_vehicles_size(vehicle_classes)
self.vehicles_objs = list()
self.init_vehicles_objs(vehicles_distances, vehicles_yaw_angle_drift,
vehicle_classes, vehicles_sizes,
positions_in_lane)
self.vcls_distance_threshold = 2 # minimum of 2 meters between vehicles
self.remove_overlapping_vehicles()
def calc_host_lane_id(self):
possible_hosts_list = list(range(self.num_main_lanes))
host_lane_id = 0
if self.num_main_lanes == 1:
host_lane_id = 0
elif self.num_main_lanes == 2:
host_lane_id = get_rand_out_of_list_item(possible_hosts_list, objects_weights=[0.7, 0.3])
elif self.num_main_lanes == 3:
host_lane_id = get_rand_out_of_list_item(possible_hosts_list, objects_weights=[0.6, 0.2, 0.2])
elif self.num_main_lanes == 4:
host_lane_id = get_rand_out_of_list_item(possible_hosts_list, objects_weights=[0.6, 0.2, 0.1, 0.1])
elif self.num_main_lanes == 5:
host_lane_id = get_rand_out_of_list_item(possible_hosts_list, objects_weights=[0.6, 0.15, 0.08, 0.08, 0.09])
else:
print(" not known number of nummmain lanes =", self.num_main_lanes)
return host_lane_id
def calc_gaps(self):
has_gap = get_rand_out_of_list_item([True, False],
objects_weights=[0.05, 0.95])
gap = dict()
if has_gap:
gap['begin'] = get_rand_range(0, 100)
gap['length'] = get_rand_range(5, 30)
else:
gap['begin'] = 0 # get_rand_range(0, 100)
gap['length'] = 0 # get_rand_range(5, 30)
return gap
def init_vehicles_objs(self, vehicles_distances, vehicles_yaw_angle_drift,
vehicle_classes, vehicles_sizes, positions_in_lane):
"""
Creates the list of SingleVehicle object in self.vehicles_objs
"""
lanes_idxes = self.num_vehicles_per_lane.cumsum()
lane_idx = 0
vcl_id = 0
for i in range(self.total_vehicles_num):
while i >= lanes_idxes[lane_idx]:
lane_idx += 1
visibility = 'visible'
if vehicles_distances[i] > 100:
visibility = get_rand_out_of_list_item(
['visible', 'non_visible'], objects_weights=[0.5, 0.5])
vcl = SingleVehicle(vehicles_distances[i],
vehicles_yaw_angle_drift[i],
vehicle_classes[i], vehicles_sizes[i],
lane_idx, vcl_id, visibility,
positions_in_lane[i])
self.vehicles_objs.append(vcl)
vcl_id += 1
def __init__(self):
# def get_rand_out_of_list_item(objects_list, num_items=None, objects_weights=None):
self.num_main_lanes = get_rand_out_of_list_item([1, 2, 3, 4, 5], objects_weights=[0.1, 0.35, 0.35, 0.1, 0.1])
self.host_lane_id = self.calc_host_lane_id()
self.num_lane_marks = self.num_main_lanes + 1
self.lanes_widths = get_rand_range(3.2, 4.0, num_items=self.num_main_lanes)
self.lane_marks_widths = get_rand_range(0.1, 0.3, num_items=self.num_lane_marks)
# z_range_beg_host = [0, 20]
# self.lines_mark_z_ranges[0] = np.stack((get_rand_range(0, 20), get_rand_range(100, 150))).T
self.lane_marks_mark_z_ranges = np.stack((get_rand_range(0, 10, num_items=self.num_lane_marks),
get_rand_range(50, 120, num_items=self.num_lane_marks))).T
self.lane_model_Z_positions = np.asarray([-100, 0, 100, 150, 200])
self.num_Z_points = len(self.lane_model_Z_positions)
self.lane_model_X_deltas = get_rand_range(-10, 10, num_items=self.num_Z_points)
self.lane_model_X_positions = np.zeros_like(self.lane_model_Z_positions, dtype=float)
self.lane_model_X_positions[2:] = np.cumsum(self.lane_model_X_deltas[2:])
self.lane_model_X_positions[0] = -self.lane_model_X_deltas[1]
# self.lane_model_X_positions[0] = self.lane_model_X_positions[1] - self.lane_model_X_deltas[0]
self.points = np.stack((self.lane_model_Z_positions, self.lane_model_X_positions)).T
# print("main lane points", self.points)
self.lane_models = list()
# self.host_lane_model_yaw_rad = self.host_lane_model_yaw_deg * np.pi / 180
# self.is_exit_split_type = "zero2one_unmarked_V" # "get_rand_list_item(["one2zero_unmarked_V_merge"]) # , "one2one_dashed2solid2Y" ])
self.is_exit_split_type = get_rand_out_of_list_item(["no_exit",
"zero2one_unmarked_V", "one2one_dashed2solid2Y",
"one2zero_unmarked_V_merge"], objects_weights=[0.1, 0.3, 0.3, 0.3])
self.is_exit_beg_position = get_rand_range(-80, 50) # -100, 100)
self.is_merge_beg_position = get_rand_range(0, 200) # -100, 100)
self.is_exit_lane_width = get_rand_range(3.2, 4.0)
self.is_exit_Z_positions = np.asarray([0, 100, 200, 300]) # , 200, 250, 300])
# self.is_exit_Z_positions = np.asarray([0, 60])
self.is_exit_num_Z_points = len(self.is_exit_Z_positions)
num_points_around_Z_0 = 1
self.is_exit_X_delta_deltas = get_rand_range(0, 10, num_items=self.is_exit_num_Z_points - num_points_around_Z_0)
self.is_exit_X_deltas_from_main = np.zeros_like(self.is_exit_Z_positions, dtype=float)
self.is_exit_X_deltas_from_main[num_points_around_Z_0:] = np.cumsum(self.is_exit_X_delta_deltas)
self.exit_points_X = np.zeros_like(self.is_exit_X_deltas_from_main, dtype=float)
self.exit_points_Z = np.zeros_like(self.is_exit_X_deltas_from_main, dtype=float)
# self.is_exit_X_deltas_from_main[1] = 0
# self.is_exit_X_deltas_from_main[0] = 0
self.exit_lane_left_Z_range_end = get_rand_range(150, 180)
self.exit_lane_right_Z_range_end = get_rand_range(150, 180)
self.merge_lane_left_Z_range_begin = get_rand_range(0, 20)
self.merge_lane_right_Z_range_begin = get_rand_range(10, 30)
self.exit_lane_left_width = get_rand_range(0.1, 0.3)
self.exit_lane_right_width = get_rand_range(0.1, 0.3)
if self.is_exit_split_type == "no_exit":
self.num_exit_lanes = 0
elif self.is_exit_split_type == "zero2one_unmarked_V":
self.num_exit_lanes = 1
elif self.is_exit_split_type == "one2one_dashed2solid2Y":
self.num_exit_lanes = 1
elif self.is_exit_split_type == "one2zero_unmarked_V_merge":
self.num_exit_lanes = 1
self.flip_bk_ft = False # True #get_rand_out_of_list_item([True, False])
self.calc_all_lanes()
self.num_total_lanes = len(self.lane_models)
seg_fvi_filename = "seg_front_view_image_" + dt_string + ".png"
fvi_seg_pnts_filename = "seg_drawed_points_" + dt_string
fvi_seg_cropped_pnts_fp = "seg_crop_drawed_points_" + dt_string
seg_cropped_fvi_filename = "seg_crop_front_view_image_" + dt_string + ".png"
csv_filename = seg_fvi_filename.replace('seg',
'out').replace('png', 'csv')
csv_crop_filename = seg_cropped_fvi_filename.replace('seg',
'out').replace(
'png', 'csv')
tvi_filename = "top_view_image_" + dt_string + ".png"
tvi_vehicles_filename = "top_view_image_vcls_" + dt_string + ".png"
md_filename = "meta_data_" + dt_string + ".json"
train_val_dir = get_rand_out_of_list_item(['train', 'val'],
objects_weights=[0.8, 0.2])
fvi_fp = os.path.join(fv_dir[train_val_dir], fvi_filename)
fvi_seg_fp = os.path.join(fv_dir[train_val_dir], seg_fvi_filename)
fvi_seg_cropped_fp = os.path.join(fv_dir[train_val_dir],
seg_cropped_fvi_filename)
drawed_points_fp = os.path.join(fv_dir[train_val_dir],
drawed_points_fvi_filename)
fvi_seg_pnts_fp = os.path.join(fv_dir[train_val_dir],
fvi_seg_pnts_filename)
fvi_seg_crop_pnts_fp = os.path.join(fv_dir[train_val_dir],
fvi_seg_cropped_pnts_fp)
tvi_fp = os.path.join(tv_dir[train_val_dir], tvi_filename)
tvi_v_fp = os.path.join(tv_v_dir[train_val_dir], tvi_vehicles_filename)
md_fp = os.path.join(md_dir[train_val_dir], md_filename)