def _edit_major_cv_image(self, major_cv_image):
""" Apply all the editing for the Major 45degree camera image
Args:
major_cv_image (Image): Image straight from the camera
Returns:
Image: Edited main camera image
"""
# Applying gradient to whole major image and then writing text
major_cv_image = utils.apply_gradient(major_cv_image,
self.gradient_img,
self.gradient_alpha)
# Subscribing to the agent metrics
mp4_video_metrics_info = list()
for racecar_info, mp4_video_metrics_srv in zip(
self.racecars_info, self.mp4_video_metrics_srv_list):
mp4_video_metrics = mp4_video_metrics_srv(VideoMetricsSrvRequest())
mp4_video_metrics_info.append(mp4_video_metrics)
# Adding display name to the image
agents_speed = 0
agent_done = False
for i, racecar_info in enumerate(self.racecars_info):
loc_x, loc_y = XYPixelLoc.MULTI_AGENT_DISPLAY_NAME_LOC.value[i][
0], XYPixelLoc.MULTI_AGENT_DISPLAY_NAME_LOC.value[i][1]
# Display name (Racer name/Model name)
display_name = racecar_info['display_name']
display_name_txt = display_name if len(
display_name) < 15 else "{}...".format(display_name[:15])
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=display_name_txt,
loc=(loc_x, loc_y),
font=self.amazon_ember_regular_20px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# Lap Counter
loc_y += 30
total_laps = rospy.get_param("NUMBER_OF_TRIALS", 0)
current_lap = int(mp4_video_metrics_info[i].lap_counter) + 1
lap_counter_text = "{}/{}".format(current_lap, total_laps)
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=lap_counter_text,
loc=(loc_x, loc_y),
font=self.amazon_ember_heavy_30px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# Reset counter
loc_y += 45
reset_counter_text = "Reset | {}".format(
mp4_video_metrics_info[i].reset_counter)
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=reset_counter_text,
loc=(loc_x, loc_y),
font=self.amazon_ember_light_18px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
if self.racecar_name == racecar_info['name']:
agents_speed = mp4_video_metrics_info[i].throttle
# The race is complete when total lap is same as current lap and done flag is set
agent_done = agent_done or (mp4_video_metrics_info[i].done and
(current_lap == int(total_laps)))
# Speed
loc_x, loc_y = XYPixelLoc.SPEED_EVAL_LOC.value
if self.is_league_leaderboard:
loc_x, loc_y = XYPixelLoc.SPEED_LEADERBOARD_LOC.value
speed_text = "{} m/s".format(
utils.get_speed_formatted_str(agents_speed))
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=speed_text,
loc=(loc_x, loc_y),
font=self.amazon_ember_light_20px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# Leaderboard name
if self.is_league_leaderboard:
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=self.leaderboard_name,
loc=XYPixelLoc.LEADERBOARD_NAME_LOC.value,
font=self.amazon_ember_regular_16px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# Evaluation type
loc_x, loc_y = XYPixelLoc.RACE_TYPE_EVAL_LOC.value
if self.is_league_leaderboard:
loc_x, loc_y = XYPixelLoc.RACE_TYPE_RACE_LOC.value
race_text = "race" if self.is_racing else "evaluation"
evaluation_type_txt = "{} {}".format(
RACE_TYPE_TO_VIDEO_TEXT_MAPPING[self.race_type], race_text)
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=evaluation_type_txt,
loc=(loc_x, loc_y),
font=self.amazon_ember_light_italic_20px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# total_evaluation_time (Race time)
loc_x, loc_y = XYPixelLoc.MULTI_AGENT_EVAL_TIME.value
total_eval_milli_seconds = mp4_video_metrics_info[
0].total_evaluation_time
time_delta = datetime.timedelta(milliseconds=total_eval_milli_seconds)
total_eval_time_text = "Race | {}".format(
utils.milliseconds_to_timeformat(time_delta))
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=total_eval_time_text,
loc=(loc_x, loc_y),
font=self.amazon_ember_light_18px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# AWS Deepracer logo at the bottom for the community leaderboard
if self.is_league_leaderboard:
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=AWS_DEEPRACER_WATER_MARK,
loc=XYPixelLoc.AWS_DEEPRACER_WATER_MARK_LOC.value,
font=self.amazon_ember_regular_16px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# Check if the done flag is set and set the banner appropriately
if agent_done:
# When the cv2 text is written, it automatically drops the alpha value of the image
rel_y_offset = XYPixelLoc.TRACK_IMG_WITH_OFFSET_LOC.value[
1] if self.is_league_leaderboard else 0
major_cv_image = cv2.cvtColor(major_cv_image, cv2.COLOR_RGB2RGBA)
racecomplete_image = utils.get_image(
TrackAssetsIconographicPngs.RACE_COMPLETE_OVERLAY_PNG.value,
IconographicImageSize.RACE_COMPLETE_IMAGE_SIZE.value)
x_offset = major_cv_image.shape[
1] - racecomplete_image.shape[1] // 2
y_offset = major_cv_image.shape[
0] - RACE_COMPLETE_Y_OFFSET - rel_y_offset - racecomplete_image.shape[
0] // 2
major_cv_image = utils.plot_rectangular_image_on_main_image(
major_cv_image, racecomplete_image, (x_offset, y_offset))
return major_cv_image
def _basic_racer_info_display(self,
major_cv_image,
racers_ranking,
cur_racer_metrics_info,
show_racer_name=True):
""" Basic display editting of the main camera following the car.
All the information at the bottom left of the MP4 is edited here.
Arguments:
major_cv_image (Image): Main camera image for the racecar
racers_ranking (OrderedDict): Sorted ordered dict with racer_number and progress percentage along with lap
cur_racer_metrics_info (dict): Given racers metric information
Keyword Arguments:
show_racer_name (bool): All the other states call this. But the finisher state does not have enough
space to show the display name.(default: {True})
Returns:
major_cv_image (Image): Edited Main camera image
"""
if show_racer_name:
# Adding display name to the image
loc_x, loc_y = XYPixelLoc.F1_DISPLAY_NAME_LOC.value
display_name = self.racecars_info[
self.racecar_index]['display_name']
display_name_txt = display_name if len(
display_name) <= 6 else "{}".format(display_name[:6])
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=display_name_txt,
loc=(loc_x, loc_y),
font=self.formula1_display_regular_14px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# Racers ranking
loc_x, loc_y = XYPixelLoc.F1_RANKING_LOC.value
cur_rank = self._get_racecar_ranking(racers_ranking,
self.racecar_index)
rank_txt = "Rank {}/{}".format(cur_rank, len(self.racecars_info))
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=rank_txt,
loc=(loc_x, loc_y),
font=self.formula1_display_regular_16px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# Lap Counter|Total eval|gap time
# Lap counter calculation
loc_x, loc_y = XYPixelLoc.F1_LAP_EVAL_GAP_LOC.value
current_lap = min(
int(cur_racer_metrics_info.lap_counter) + 1, int(self.total_laps))
lap_counter_text = "Lap {:2d} / {:2d}".format(current_lap,
int(self.total_laps))
# Total eval time
if self.racecar_index in self._finished_lap_time:
# If the racer finished the race then lock the total evaluation time to finished lap time.
total_eval_milli_seconds = self._finished_lap_time[
self.racecar_index]
else:
total_eval_milli_seconds = cur_racer_metrics_info.total_evaluation_time
time_delta = datetime.timedelta(milliseconds=total_eval_milli_seconds)
total_eval_time_text = "{}".format(
utils.milliseconds_to_timeformat(time_delta))
# Writing to the frame (Lap Counter|Total eval|gap time)
lap_elapsed_gap_time = "{} | {} | Gap ".format(lap_counter_text,
total_eval_time_text)
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=lap_elapsed_gap_time,
loc=(loc_x, loc_y),
font=self.formula1_display_regular_16px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# Gap (In orange color)
loc_x, loc_y = XYPixelLoc.F1_LAP_EVAL_GAP_VAL_LOC.value
# For the racer ranking 0, we see small floating number for the gap. Hence making it zero
if cur_rank == 1:
gap_time = 0
gap_time = self._get_gap_time(racers_ranking, self.racecar_index,
cur_racer_metrics_info)
gap_time_text = "+{:.3f}".format(gap_time)
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=gap_time_text,
loc=(loc_x, loc_y),
font=self.formula1_display_regular_16px,
font_color=RaceCarColorToRGB.Orange.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# Leaderboard name
f1_water_mark_text = "{}".format(self.leaderboard_name)
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=f1_water_mark_text,
loc=XYPixelLoc.F1_LEADERBOARD_NAME_LOC.value,
font=self.formula1_display_regular_12px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# Do all plotting of images at the end
if show_racer_name:
# Draw racer color code
loc_x, loc_y = XYPixelLoc.F1_DISPLAY_NAME_SLASH_LOC.value
major_cv_image = utils.plot_rectangular_image_on_main_image(
major_cv_image,
self._racer_color_code_slash_img[self.racecar_index],
(loc_x, loc_y))
major_cv_image = cv2.cvtColor(major_cv_image, cv2.COLOR_RGB2BGRA)
return major_cv_image
def _edit_major_cv_image(self, major_cv_image, mp4_video_metrics_info):
""" Apply all the editing for the Major 45degree camera image
Args:
major_cv_image (Image): Image straight from the camera
mp4_video_metrics_info (dict): rest image editting info
Returns:
Image: Edited main camera image
"""
major_cv_image = utils.apply_gradient(major_cv_image,
self.gradient_alpha_rgb_mul,
self.one_minus_gradient_alpha)
#########################
# update display params #
#########################
episode_status = mp4_video_metrics_info[
self.racecar_index].episode_status
# Display name (Racer name/Model name)
display_name = self.racecar_info[self.racecar_index]['display_name']
# total_evaluation_time (Race time)
total_eval_milli_seconds = mp4_video_metrics_info[
self.racecar_index].total_evaluation_time
# Reset counter
reset_counter = mp4_video_metrics_info[
self.racecar_index].reset_counter
# Speed
speed = mp4_video_metrics_info[self.racecar_index].throttle
# Current progress
current_progress = mp4_video_metrics_info[
self.racecar_index].completion_percentage
# Prepare a dict for finite state machine on event call
info_dict = {
VirtualEventMP4Params.COUNTDOWN_TIMER.value:
mp4_video_metrics_info[self.racecar_index].pause_duration,
VirtualEventMP4Params.MAJOR_CV_IMAGE.value:
major_cv_image,
VirtualEventMP4Params.CURRENT_LAP.value:
self._current_lap,
VirtualEventMP4Params.TOTAL_EVAL_SECONDS.value:
total_eval_milli_seconds,
VirtualEventMP4Params.RESET_COUNTER.value:
reset_counter,
VirtualEventMP4Params.SPEED.value:
speed,
VirtualEventMP4Params.CURR_PROGRESS.value:
current_progress,
VirtualEventMP4Params.LAST_EVAL_SECONDS.value:
self._last_eval_time,
VirtualEventMP4Params.X_MIN.value:
self._track_x_min,
VirtualEventMP4Params.X_MAX.value:
self._track_x_max,
VirtualEventMP4Params.Y_MIN.value:
self._track_y_min,
VirtualEventMP4Params.Y_MAX.value:
self._track_y_max,
VirtualEventMP4Params.SECTOR_TIMES.value:
self._sector_times,
VirtualEventMP4Params.CURR_LAP_TIME.value:
self._curr_lap_time,
VirtualEventMP4Params.SECTOR_IMAGES.value:
self._sectors_img_dict,
VirtualEventMP4Params.FADER_OBJ.value:
self._fader_obj
}
#####################
# run state machine #
#####################
# virtual event image edit finite state machine on event
info_dict = self._image_edit_fsm.execute(input_val={
'event': episode_status,
'info_dict': info_dict
})
# update display param from the finite state machine return value
major_cv_image = info_dict[VirtualEventMP4Params.MAJOR_CV_IMAGE.value]
total_eval_milli_seconds = info_dict[
VirtualEventMP4Params.TOTAL_EVAL_SECONDS.value]
reset_counter = info_dict[VirtualEventMP4Params.RESET_COUNTER.value]
speed = info_dict[VirtualEventMP4Params.SPEED.value]
self._current_lap = info_dict[VirtualEventMP4Params.CURRENT_LAP.value]
self._last_eval_time = info_dict[
VirtualEventMP4Params.LAST_EVAL_SECONDS.value]
self._sector_times = info_dict[
VirtualEventMP4Params.SECTOR_TIMES.value]
self._curr_lap_time = info_dict[
VirtualEventMP4Params.CURR_LAP_TIME.value]
# Time remaining digit
loc_x, loc_y = VirtualEventXYPixelLoc.TIME_REMAINING_DIGIT.value
time_remaining = self.race_duration - total_eval_milli_seconds
time_remaining = time_remaining if time_remaining > 0.0 else 0.0
time_remaining = datetime.timedelta(milliseconds=time_remaining)
time_remaining = utils.milliseconds_to_timeformat(time_remaining)
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=time_remaining,
loc=(loc_x, loc_y),
font=self.amazon_ember_regular_28px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# Speed digit
loc_x, loc_y = VirtualEventXYPixelLoc.SPEED_DIGIT.value
speed_text = utils.get_speed_formatted_str(speed)
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=speed_text,
loc=(loc_x, loc_y),
font=self.amazon_ember_regular_28px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# Reset digit
loc_x, loc_y = VirtualEventXYPixelLoc.RESET_DIGIT.value
reset_counter_text = "{}".format(reset_counter)
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=reset_counter_text,
loc=(loc_x, loc_y),
font=self.amazon_ember_regular_28px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# curent lap time digit
loc_x, loc_y = VirtualEventXYPixelLoc.CURRENT_LAP_TIME_DIGIT.value
curr_lap_time = utils.milliseconds_to_timeformat(
datetime.timedelta(milliseconds=self._curr_lap_time))
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=curr_lap_time,
loc=(loc_x, loc_y),
font=self.amazon_ember_regular_28px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# best lap time digit
loc_x, loc_y = VirtualEventXYPixelLoc.BEST_LAP_TIME_DIGIT.value
best_lap_time = mp4_video_metrics_info[
self.racecar_index].best_lap_time
# The initial default best_lap_time from s3_metrics.py is inf
# If the ros service in s3_metrics.py has not come up yet, best_lap_time is 0
best_lap_time = utils.milliseconds_to_timeformat(
datetime.timedelta(milliseconds=best_lap_time)) \
if best_lap_time != float("inf") and best_lap_time != 0 else "--:--.---"
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=best_lap_time,
loc=(loc_x, loc_y),
font=self.amazon_ember_regular_28px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
major_cv_image = cv2.cvtColor(major_cv_image, cv2.COLOR_RGB2BGRA)
return major_cv_image
def _edit_major_cv_image(self, major_cv_image, mp4_video_metrics_info):
""" Apply all the editing for the Major 45degree camera image
Args:
major_cv_image (Image): Image straight from the camera
Returns:
Image: Edited main camera image
"""
# Applying gradient to whole major image and then writing text
major_cv_image = utils.apply_gradient(major_cv_image,
self.gradient_alpha_rgb_mul,
self.one_minus_gradient_alpha)
# Top left location of the picture
loc_x, loc_y = XYPixelLoc.SINGLE_AGENT_DISPLAY_NAME_LOC.value
# Display name (Racer name/Model name)
display_name = self.racecar_info[self.racecar_index]['display_name']
display_name_txt = display_name if len(
display_name) < 15 else "{}...".format(display_name[:15])
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=display_name_txt,
loc=(loc_x, loc_y),
font=self.amazon_ember_regular_20px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# Lap Counter
loc_y += 30
total_laps = rospy.get_param("NUMBER_OF_TRIALS", 0)
current_lap = min(
int(mp4_video_metrics_info[self.racecar_index].lap_counter) + 1,
total_laps)
lap_counter_text = "{}/{}".format(current_lap, total_laps)
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=lap_counter_text,
loc=(loc_x, loc_y),
font=self.amazon_ember_heavy_30px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# total_evaluation_time (Race time)
loc_y += 45
total_eval_milli_seconds = mp4_video_metrics_info[
self.racecar_index].total_evaluation_time
time_delta = datetime.timedelta(milliseconds=total_eval_milli_seconds)
total_eval_time_text = "Race | {}".format(
utils.milliseconds_to_timeformat(time_delta))
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=total_eval_time_text,
loc=(loc_x, loc_y),
font=self.amazon_ember_light_18px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# Reset counter
loc_y += 25
reset_counter_text = "Reset | {}".format(
mp4_video_metrics_info[self.racecar_index].reset_counter)
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=reset_counter_text,
loc=(loc_x, loc_y),
font=self.amazon_ember_light_18px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# Speed
loc_x, loc_y = XYPixelLoc.SPEED_EVAL_LOC.value
if self.is_league_leaderboard:
loc_x, loc_y = XYPixelLoc.SPEED_LEADERBOARD_LOC.value
speed_text = "{} m/s".format(
utils.get_speed_formatted_str(
mp4_video_metrics_info[self.racecar_index].throttle))
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=speed_text,
loc=(loc_x, loc_y),
font=self.amazon_ember_light_20px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# Leaderboard name
if self.is_league_leaderboard:
loc_x, loc_y = XYPixelLoc.LEADERBOARD_NAME_LOC.value
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=self.leaderboard_name,
loc=(loc_x, loc_y),
font=self.amazon_ember_regular_16px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# Evaluation type
loc_x, loc_y = XYPixelLoc.RACE_TYPE_EVAL_LOC.value
if self.is_league_leaderboard:
loc_x, loc_y = XYPixelLoc.RACE_TYPE_RACE_LOC.value
race_text = "race" if self.is_racing else "evaluation"
evaluation_type_txt = "{} {}".format(
RACE_TYPE_TO_VIDEO_TEXT_MAPPING[self.race_type], race_text)
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=evaluation_type_txt,
loc=(loc_x, loc_y),
font=self.amazon_ember_light_italic_20px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# AWS Deepracer logo at the bottom for the community leaderboard
if self.is_league_leaderboard:
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=AWS_DEEPRACER_WATER_MARK,
loc=XYPixelLoc.AWS_DEEPRACER_WATER_MARK_LOC.value,
font=self.amazon_ember_regular_16px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# Check if the done flag is set and set the banner appropriately
if mp4_video_metrics_info[self.racecar_index].done and (
int(total_laps) >= current_lap):
# When the cv2 text is written, it automatically drops the alpha value of the image
rel_y_offset = XYPixelLoc.TRACK_IMG_WITH_OFFSET_LOC.value[
1] if self.is_league_leaderboard else 0
racecomplete_image = utils.get_image(
TrackAssetsIconographicPngs.RACE_COMPLETE_OVERLAY_PNG.value,
IconographicImageSize.RACE_COMPLETE_IMAGE_SIZE.value)
x_offset = major_cv_image.shape[
1] - racecomplete_image.shape[1] // 2
y_offset = major_cv_image.shape[
0] - RACE_COMPLETE_Y_OFFSET - rel_y_offset - racecomplete_image.shape[
0] // 2
major_cv_image = utils.plot_rectangular_image_on_main_image(
major_cv_image, racecomplete_image, (x_offset, y_offset))
major_cv_image = cv2.cvtColor(major_cv_image, cv2.COLOR_RGB2BGRA)
return major_cv_image
def _edit_major_cv_image(self, major_cv_image):
""" Apply all the editing for the Major 45degree camera image
Args:
major_cv_image (Image): Image straight from the camera
Returns:
Image: Edited main camera image
"""
# Applying gradient to whole major image and then writing text
major_cv_image = utils.apply_gradient(major_cv_image,
self.gradient_img,
self.gradient_alpha)
# Subscribing to the agent metrics
mp4_video_metrics_info = list()
for racecar_info, mp4_video_metrics_srv in zip(
self.racecars_info, self.mp4_video_metrics_srv_list):
mp4_video_metrics = mp4_video_metrics_srv(VideoMetricsSrvRequest())
mp4_video_metrics_info.append(mp4_video_metrics)
# Adding display name to the image
display_name_loc = [(10, 10), (450, 10)]
agents_speed = 0
agent_done = False
for i, racecar_info in enumerate(self.racecars_info):
loc_x, loc_y = display_name_loc[i][0], display_name_loc[i][1]
# Display name (Racer name/Model name)
display_name = racecar_info['display_name']
display_name_txt = display_name if len(
display_name) < 15 else "{}...".format(display_name[:15])
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=display_name_txt,
loc=(loc_x, loc_y),
font=self.amazon_ember_regular_20px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# Lap Counter
loc_y += 30
total_laps = rospy.get_param("NUMBER_OF_TRIALS", 0)
lap_counter_text = "{}/{}".format(
int(mp4_video_metrics_info[i].lap_counter), total_laps)
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=lap_counter_text,
loc=(loc_x, loc_y),
font=self.amazon_ember_heavy_30px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# Reset counter
loc_y += 45
reset_counter_text = "Reset | {}".format(
mp4_video_metrics_info[i].reset_counter)
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=reset_counter_text,
loc=(loc_x, loc_y),
font=self.amazon_ember_light_18px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
if self.racecar_name == racecar_info['name']:
agents_speed = mp4_video_metrics_info[i].throttle
agent_done = agent_done or mp4_video_metrics_info[i].done
# Speed
loc_x, loc_y = 10, 420
speed_text = "{} m/s".format(
utils.get_speed_formatted_str(agents_speed))
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=speed_text,
loc=(loc_x, loc_y),
font=self.amazon_ember_light_20px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# Evaluation type
loc_y += 25
# TODO - Show text based on whether its a race or customer run evaluation
race_text = "race"
evaluation_type_txt = "{} {}".format(
RACE_TYPE_TO_VIDEO_TEXT_MAPPING[self.race_type], race_text)
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=evaluation_type_txt,
loc=(loc_x, loc_y),
font=self.amazon_ember_light_italic_20px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# total_evaluation_time (Race time)
loc_x, loc_y = 240, 10
total_eval_milli_seconds = mp4_video_metrics_info[
0].total_evaluation_time
time_delta = datetime.timedelta(milliseconds=total_eval_milli_seconds)
total_eval_time_text = "Race | {}".format(
utils.milliseconds_to_timeformat(time_delta))
major_cv_image = utils.write_text_on_image(
image=major_cv_image,
text=total_eval_time_text,
loc=(loc_x, loc_y),
font=self.amazon_ember_light_18px,
font_color=RaceCarColorToRGB.White.value,
font_shadow_color=RaceCarColorToRGB.Black.value)
# Check if the done flag is set and set the banner appropriately
if agent_done:
# When the cv2 text is written, it automatically drops the alpha value of the image
major_cv_image = cv2.cvtColor(major_cv_image, cv2.COLOR_RGB2RGBA)
racecomplete_image = utils.get_image(
TrackAssetsIconographicPngs.RACE_COMPLETE_OVERLAY_PNG.value,
IconographicImageSize.RACE_COMPLETE_IMAGE_SIZE.value)
x_offset = major_cv_image.shape[
1] - racecomplete_image.shape[1] // 2
y_offset = major_cv_image.shape[
0] - 180 - racecomplete_image.shape[0] // 2
major_cv_image = utils.plot_rectangular_image_on_main_image(
major_cv_image, racecomplete_image, (x_offset, y_offset))
return major_cv_image
