def get_section_start_and_finish_events(self, start, finish, track: Track):
if not self.probably_finishes_section_(start, finish):
return None
start_event = None
finish_event = None
start_dist = 9999
finish_dist = 9999
for e in self.events:
if not finish_event and are_close_waypoint_ids(
e.closest_waypoint_index, start, track):
(x2, y2) = track.get_waypoint(start)
dist = (x2 - e.x) * (x2 - e.x) + (y2 - e.y) * (y2 - e.y)
if dist < start_dist:
start_dist = dist
start_event = e
if start_event and are_close_waypoint_ids(e.closest_waypoint_index,
finish, track):
(x2, y2) = track.get_waypoint(finish)
dist = (x2 - e.x) * (x2 - e.x) + (y2 - e.y) * (y2 - e.y)
if dist < finish_dist:
finish_dist = dist
finish_event = e
if finish_event:
return start_event, finish_event
else:
return None
def get_reward_input_params(self, current_track: Track):
point = (self.x, self.y)
side = current_track.get_position_of_point_relative_to_waypoint(
point, self.closest_waypoint_index)
params = {
'all_wheels_on_track':
self.all_wheels_on_track,
'x':
self.x,
'y':
self.y,
'heading':
self.heading,
'distance_from_center':
self.distance_from_center,
'projection_distance':
0.0, # TODO
'progress':
self.progress,
'steps':
float(self.step),
'speed':
float(self.speed),
'steering_angle':
float(self.steering_angle),
'track_width':
current_track.get_width(),
'track_length':
float(self.track_length),
'waypoints':
current_track.get_all_waypoints(),
'closest_waypoints':
[int(self.before_waypoint_index),
int(self.after_waypoint_index)],
'is_left_of_center':
side == "L",
'is_reversed':
self.status == _STATUS_REVERSED,
'is_crashed':
self.status == _STATUS_CRASHED,
'is_offtrack':
self.status == _STATUS_OFF_TRACK,
'closest_objects': [0, 0], # TODO
'objects_location': [], # TODO
'objects_left_of_center': [], # TODO
'object_in_camera': [], # TODO
'objects_speed': [], # TODO
'objects_heading': [], # TODO
'objects_distance_from_center': [], # TODO
'objects_distance': [] # TODO
}
return params
def _set_skew_on_events(self, track: Track):
e: Event
for e in self.events:
(track_bearing,
_) = track.get_bearing_and_distance_to_next_waypoint(
e.before_waypoint_index)
e.skew = get_turn_between_directions(track_bearing, e.true_bearing)
def zoom_sector(self, track: Track, sector: str):
(self.zoom_x, self.zoom_y, self.zoom_x2, self.zoom_y2) = track.get_sector_coordinates(sector)
self.zoom_x -= SECTOR_BORDER
self.zoom_y -= SECTOR_BORDER
self.zoom_x2 += SECTOR_BORDER
self.zoom_y2 += SECTOR_BORDER
self.zoom_in = True
def redraw(self, current_track :Track, track_graphics, analyzer):
track_graphics.reset_to_blank()
current_track.configure_track_graphics(track_graphics)
for do in self.drawing_order:
if do == "G" and self.grid_on:
current_track.draw_grid(track_graphics, COLOUR_GREY)
if do == "T":
current_track.draw_track_edges(track_graphics, self.track_colour)
# current_track.draw_section_dividers(track_graphics, self.track_colour)
current_track.draw_starting_line(track_graphics, self.track_colour)
if self.waypoints_on:
current_track.draw_waypoints(track_graphics, self.track_colour, self.waypoint_minor_size, self.waypoint_major_size)
if do == "A":
analyzer.redraw()
def are_close_waypoint_ids(id1, id2, track: Track):
if abs(id1 - id2) <= 2:
return True
if max(id1, id2) >= track.get_number_of_waypoints() - 1 and min(id1,
id2) <= 2:
return True
else:
return False
def _set_distance_from_center_on_events(self, track: Track):
for e in self.events:
current_location = (e.x, e.y)
closest_waypoint = track.get_waypoint(e.closest_waypoint_index)
next_waypoint = track.get_next_different_waypoint(
e.closest_waypoint_index)
previous_waypoint = track.get_previous_different_waypoint(
e.closest_waypoint_index)
distance_of_next_waypoint = get_distance_between_points(
current_location, next_waypoint)
distance_of_previous_waypoint = get_distance_between_points(
current_location, previous_waypoint)
if distance_of_next_waypoint < distance_of_previous_waypoint:
e.distance_from_center = get_distance_of_point_from_line(
current_location, closest_waypoint, next_waypoint)
else:
e.distance_from_center = get_distance_of_point_from_line(
current_location, closest_waypoint, previous_waypoint)
def set_projected_distances_on_events(self, track: Track):
e: Event
for e in self.events:
e.projected_travel_distance = track.get_projected_distance_on_track(
(e.x, e.y), e.true_bearing, e.closest_waypoint_index)
def _set_before_and_after_waypoints_on_events(self, track: Track):
e: Event
for e in self.events:
(e.before_waypoint_index,
e.after_waypoint_index) = track.get_waypoint_ids_before_and_after(
(e.x, e.y), e.closest_waypoint_index)
def get_starting_position_as_percent_from_race_start(self, track: Track):
first_event_percent = track.get_waypoint_percent_from_race_start(
self.events[0].closest_waypoint_index)
# 5 is magic number because there are 20 evenly spaced start points, i.e. every 5% round the track
return round(first_event_percent / 5) * 5
def redraw(self, current_track :Track, track_graphics, analyzer, background_analyser, episode_filter: EpisodeFilter):
analyzer.recalculate()
if background_analyser:
background_analyser.recalculate()
track_graphics.reset_to_blank()
if self.zoom_in and self.zoom_x:
track_graphics.set_track_area(self.zoom_x, self.zoom_y, self.zoom_x2, self.zoom_y2)
else:
current_track.configure_track_graphics(track_graphics)
for do in self.drawing_order:
if do == "G" and self.grid_on:
current_track.draw_grid(track_graphics, COLOUR_GREY)
if do == "T":
current_track.draw_track_edges(track_graphics, self.track_colour)
if episode_filter.filter_complete_section:
(start, finish) = episode_filter.filter_complete_section
current_track.draw_section_highlight(track_graphics, self.track_colour, start, finish)
current_track.draw_starting_line(track_graphics, self.track_colour)
if self.sectors_on:
current_track.draw_sector_dividers(track_graphics, self.track_colour)
current_track.draw_sector_labels(track_graphics, self.track_colour)
if self.waypoints_on:
current_track.draw_waypoints(track_graphics, self.track_colour, self.waypoint_minor_size, self.waypoint_major_size)
if self.waypoint_labels_on:
current_track.draw_waypoint_labels(track_graphics, self.track_colour, 10)
if do == "A":
if background_analyser:
background_analyser.redraw()
analyzer.redraw()
if do == "N" and self.annotations_on:
current_track.draw_annotations(track_graphics)
def show_event(self, event: Event, track: Track):
(previous_bearing,
_) = track.get_bearing_and_distance_from_previous_waypoint(
event.before_waypoint_index)
(current_bearing, _) = track.get_bearing_and_distance_to_next_waypoint(
event.before_waypoint_index)
(next_bearing, _) = track.get_bearing_and_distance_to_next_waypoint(
event.after_waypoint_index)
self.waypoint_lap_position.set(
str(
round(
track.get_waypoint_percent_from_race_start(
event.closest_waypoint_index), 1)) + " %")
self.waypoint_previous_id.set(str(event.before_waypoint_index))
self.waypoint_closest_id.set(str(event.closest_waypoint_index))
self.waypoint_next_id.set(str(event.after_waypoint_index))
self.waypoint_previous_bearing.set(str(round(previous_bearing)))
self.waypoint_current_bearing.set(str(round(current_bearing)))
self.waypoint_next_bearing.set(str(round(next_bearing)))
self.state_progress.set(str(round(event.progress, 1)) + " %")
self.state_time.set(str(round(event.time_elapsed, 1)) + " secs")
self.state_step.set(str(event.step))
self.state_track_speed.set(str(round(event.track_speed, 1)) + " m/s")
self.state_progress_speed.set(
str(round(event.progress_speed, 1)) + " m/s")
self.state_heading.set(str(round(event.heading)))
self.state_true_bearing.set(str(round(event.true_bearing)))
self.state_slide.set(str(round(event.slide)))
self.state_skew.set(str(round(event.skew)))
self.state_side.set(
track.get_position_of_point_relative_to_waypoint(
(event.x, event.y), event.closest_waypoint_index))
self.state_distance_from_centre.set(
str(round(event.distance_from_center, 2)))
self.state_all_wheels_on_track.set(str(event.all_wheels_on_track))
if event.acceleration > 0.0:
self.state_acceleration.set(
str(round(event.acceleration, 1)) + " m/s/s")
else:
self.state_acceleration.set("---")
if event.braking > 0.0:
self.state_braking.set(str(round(event.braking, 1)) + " m/s/s")
else:
self.state_braking.set("---")
self.state_projected_travel_distance.set(
str(round(event.projected_travel_distance, 1)) + " m")
self.action_id.set(str(event.action_taken))
self.action_steering.set(get_formatted_steering(event.steering_angle))
self.action_speed.set(str(event.speed) + " m/s")
self.action_sequence.set(str(event.sequence_count))
self.reward_value.set(get_pretty_large_float(round(event.reward, 5)))
self.reward_average.set(
get_pretty_large_integer(event.average_reward_so_far))
self.reward_total.set(get_pretty_large_integer(event.reward_total))
self.discounted_future_reward.set(
get_pretty_large_integer(event.discounted_future_rewards[0]))
if self._config_manager.get_calculate_new_reward():
self.new_reward.set(
get_pretty_large_float(round(event.new_reward, 5)))
self.new_discounted_future_reward.set(
get_pretty_large_integer(event.new_discounted_future_reward))
if self._config_manager.get_calculate_alternate_discount_factors():
for i, r in enumerate(self.other_discounted_future_rewards):
r.set(
get_pretty_large_integer(
event.discounted_future_rewards[i + 1]))
self.debug_output.set(get_formatted_debug(
event.debug_log, 10, 80, [])) # TODO - expose configuration
self.lift()