def tide_total(grib_path, wp_from, wp_to, start_time, speed):
step_size = 0.25 # 15 minutes
dist = nav.haversine_distance(wp_from, wp_to)
bearing = nav.bearing(wp_from, wp_to)
ETA_hr = dist / speed
partial_step = None
next_position = wp_from
#if ETA is more than 15 minutes calculate total tide at 15 miunute steps
if ETA_hr > step_size:
steps = ETA_hr / step_size
whole_steps = int(steps)
partial_step = steps - whole_steps
for step in range(0, whole_steps):
time_from_start = start_time + datetime.timedelta(
hours=(step * step_size))
seconds_from_start = (step * step_size) * 3600
step_position = nav.estimated_position(wp_from, bearing, speed,
seconds_from_start)
tide_at_step = tide_forecast(grib_path, step_position[0],
step_position[1], time_from_start)
tide_during_step = tide_at_step[0] * step_size
next_position = nav.estimated_position(next_position,
tide_at_step[1],
tide_during_step,
step_size * 3600)
#print(time_from_start, next_position, tide_at_step)
if partial_step != None or ETA_hr <= step_size:
if ETA_hr <= step_size:
step_size = ETA_hr
time_from_start = start_time + datetime.timedelta(hours=step_size)
else:
step_size = (
(whole_steps - 1) * step_size) + (step_size * partial_step)
time_from_start = start_time + datetime.timedelta(hours=step_size)
step_size = partial_step
seconds_from_start = (time_from_start - start_time).total_seconds()
step_position = nav.estimated_position(wp_from, bearing, speed,
seconds_from_start)
tide_at_step = tide_forecast(grib_path, step_position[0],
step_position[1], time_from_start)
tide_during_step = tide_at_step[0] * step_size
next_position = nav.estimated_position(next_position, tide_at_step[1],
tide_during_step,
step_size * 3600)
#print(time_from_start, next_position, tide_at_step)
return next_position
def print_course_details(anchor, course):
clear_terminal()
waypoint_count = len(course.waypoints)
#Get column widths
name_width = 0
for key, value in course.waypoints.items():
if len(value['name']) > name_width:
name_width = len(value['name'])
table_widths = "{:>"+str(len(str(waypoint_count))+1)+"}" \
" {:<"+str(name_width+1)+"}" \
" {:>7}" \
" {:>9}"
#Header
header = table_widths.format(' ', 'name', 'bearing', 'distance')
print_there(anchor[0], anchor[1], header)
#Start
row_text = table_widths.format(0, 'START', '', '')
print_there(anchor[0] + 1, anchor[1], row_text)
row_count = 1
total_dist = 0
for key, value in course.waypoints.items():
if row_count == 1: #Get bearing & distance from startline
wp_from = course.startline['lat_pin_1'], \
course.startline['lon_pin_1']
else: #From last waypoint
wp_from = course.waypoints[row_count-1]['latitude'], \
course.waypoints[row_count-1]['longitude']
wp_to = value['latitude'], value['longitude']
bearing = int(round(nav.bearing(wp_from, wp_to), 0))
dist = round(nav.haversine_distance(wp_from, wp_to), 1)
total_dist += dist
row_count += 1
row_text = table_widths.format(key, value['name'], bearing, dist)
print_there(anchor[0] + row_count, anchor[1], row_text)
#Footer / Totals
row_text = table_widths.format('', '', '', total_dist)
print_there(anchor[0] + row_count + 1, anchor[1], row_text)
def print_course_details(anchor, course):
clear_terminal()
waypoint_count = len(course.waypoints)
#Get column widths
name_width = 0
for key, value in course.waypoints.items():
if len(value['name']) > name_width:
name_width = len(value['name'])
table_widths = "{:>"+str(len(str(waypoint_count))+1)+"}" \
" {:<"+str(name_width+1)+"}" \
" {:>7}" \
" {:>9}" \
" {:>4}" \
" {:>4}" \
" {:>4}" \
" {:>4}" \
" {:>4}" \
" {:>4}" \
" {:>4}" \
" {:>4}" \
" {:>7}" \
" {:>9}" \
" {:>4}"
#Header
header = table_widths.format(' ', 'name', 'bearing', 'distance', '',
'tide', '', 'wind', '', 'SWD', '', 'SWA',
'target', 'ETA_UTC', 'CTS')
print_there(anchor[0], anchor[1], header)
#Start
tide_rate, tide_dir = tide_forecast(TIDE_FILE,
course.startline['lat_pin_1'],
course.startline['lon_pin_1'],
course.start_time_UTC)
wind_rate, wind_dir = wind_forecast_nc(WIND_FILE,
course.startline['lat_pin_1'],
course.startline['lon_pin_1'],
course.start_time_UTC)
SWD_rate, SWD_dir = nav.SWD_forecast(wind_dir, wind_rate, tide_dir,
tide_rate)
ETA = course.start_time_UTC
display_ETA = ETA.time().strftime('%H:%M')
row_text = table_widths.format(0, 'START', '', '', tide_dir, tide_rate,
wind_dir, wind_rate, SWD_dir, SWD_rate, '',
'', '', display_ETA, '')
print_there(anchor[0] + 1, anchor[1], row_text)
row_count = 1
total_dist = 0
for key, value in course.waypoints.items():
if row_count == 1: #Get bearing & distance from startline
wp_from = course.startline['lat_pin_1'], \
course.startline['lon_pin_1']
else: #From last waypoint
wp_from = course.waypoints[row_count-1]['latitude'], \
course.waypoints[row_count-1]['longitude']
wp_to = value['latitude'], value['longitude']
bearing = int(round(nav.bearing(wp_from, wp_to), 0))
SWA = nav.SWA_forecast(bearing, SWD_dir)
target = round(vessel.get_target(SWD_rate, SWA), 1)
dist = round(nav.haversine_distance(wp_from, wp_to), 1)
total_dist += dist
rough_ETA = ETA + datetime.timedelta(hours=nav.rough_ETA(dist, target))
ETA = rough_ETA
display_ETA = rough_ETA.time().strftime('%H:%M')
tide_rate, tide_dir = tide_forecast(TIDE_FILE, wp_to[0], wp_to[1],
rough_ETA)
wind_rate, wind_dir = wind_forecast_nc(WIND_FILE, wp_to[0], wp_to[1],
rough_ETA)
SWD_rate, SWD_dir = nav.SWD_forecast(wind_dir, wind_rate, tide_dir,
tide_rate)
SWA = nav.SWA_forecast(bearing, SWD_dir)
tide_offset = tide_total(TIDE_FILE, wp_from, wp_to, rough_ETA, target)
course_to_steer = int(round(nav.bearing(tide_offset, wp_to), 0))
row_count += 1
row_text = table_widths.format(key, value['name'], bearing, dist,
tide_dir, tide_rate, wind_dir,
wind_rate, SWD_dir, SWD_rate, SWA,
SWD_rate, target, display_ETA,
course_to_steer)
print_there(anchor[0] + row_count, anchor[1], row_text)
#Footer / Totals
row_text = table_widths.format('', '', '', total_dist, '', '', '', '', '',
'', '', '', '', '', '')
print_there(anchor[0] + row_count + 1, anchor[1], row_text)
def test_large_haversine_distance(self):
self.assertEqual(
9312.1,
round(
haversine_distance((50.783777, -1.309129),
(-53.310590, -140.166704)), 1))
def test_medium_haversine_distance(self):
self.assertEqual(
306.42,
round(
haversine_distance((50.783777, -1.309129),
(51.200623, -9.385454)), 2))
def test_small_haversine_distance(self):
self.assertEqual(
2.993,
round(
haversine_distance((50.783777, -1.309129),
(50.757939, -1.376420)), 3))