def get_glider_icon_style(settings, heading=None, glidername=None, glider_epoch=float('-inf')):
try:
heading = int(heading)
if 0 <= heading%360 < 180:
icon = 'glider_icon_R'
offset = heading -90-30 # TODO adjust to be more exact (based on latitude??)
else: # 180 <= heading%360 < 360:
icon = 'glider_icon_L'
offset = heading +90-5 # TODO adjust to be more exact (based on latitude??)
if glider_epoch < time.time()-60*60*possible_custom_setting(glidername,'greyout_timeout',settings):
icon = 'glider_icon_grey'
offset = 0
iconURL = possible_custom_setting(glidername, icon, settings)
except TypeError as e:
#print(type(e),e)
print('no-heading')
iconURL = possible_custom_setting(glidername,'glider_icon_tail',settings)
heading,offset = 0,0
styleUrl = iconURL[iconURL.rindex('/')+1:]+str(heading)
style = kml.Style(id=styleUrl,
BalloonStyle=kml.BalloonStyle(None),
IconStyle=kml.IconStyle(heading=offset,
iconhref=iconURL,
scale=1.5))
return style, styleUrl
def main():
netlinks = []
for ship in sorted(ship_urls.keys()):
try:
if ship_urls[ship].endswith('.xy'):
coords = parse_xy_page(ship_urls[ship])
elif ship_urls[ship].endswith('realtime'):
coords = parse_sikuliaq(ship_urls[ship])
else:
coords = parse_json_page(ship_urls[ship])
c0 = coords[-1]
except Exception as e:
print('main():', ship, type(e), e)
continue
desc = '{}\r\r\n{} GMT\r\r\nLAT: {}\r\nLON:{}\r\r\n{}'.format(
ship.title(), c0['timestamp'], c0['lat'], c0['lon'],
ship_urls[ship][11:])
desc = '<pre>{}</pre>'.format(desc)
pmark = kml.Placemark(
kml.Point(c0['lat'], c0['lon']),
name=ship,
description=desc, #, time=kml.TimeStamp(c0['epoch']),
Snippet=kml.Snippet(None),
styleUrl=kml.Style(IconStyle=kml.IconStyle(ship_icon),
BalloonStyle=kml.BalloonStyle(None)))
path = kml.Placemark(kml.LineString(coords),
name="{}s path".format(ship.title()))
doc = kml.kml(
kml.Document(pmark, path, name='{} tracker'.format(ship.title())))
checkpath = os.path.join(OUTPUT_DIR, SUBDIR)
if not os.path.exists(checkpath): os.makedirs(checkpath)
savename = os.path.join(SUBDIR, '{}.kml'.format(ship))
webaddr = os.path.join(netlink_webdir, savename)
lnk_savename = os.path.join(SUBDIR, '{}.lnk.kml'.format(ship))
lnk_webaddr = os.path.join(netlink_webdir, lnk_savename)
doc.save(os.path.join(OUTPUT_DIR, savename))
print(savename, '... SAVED TO', OUTPUT_DIR)
netlnk = kml.NetworkLink(
kml.Link(webaddr, 1200),
name=ship.title()) # 1200 = 120s*10 = 20 minutes -> refresh every
netlinks.append(netlnk)
kml.kml(netlnk).save(os.path.join(OUTPUT_DIR, lnk_savename))
print(lnk_savename, '... SAVED TO', OUTPUT_DIR)
shiptracker_doc = kml.kml(kml.Document(*netlinks, name='Shiptracker'))
shiptracker_doc.save(os.path.join(OUTPUT_DIR, SUBDIR, 'shiptracker.kml'))
print('... shiptracker.kml SAVED!!')
shiptracker_url = os.path.join(netlink_webdir, SUBDIR, 'shiptracker.kml')
shiptracker_lnk = kml.kml(
kml.Document(
kml.NetworkLink(kml.Link(shiptracker_url, 1200),
name='Shiptracker')))
shiptracker_lnk.save(os.path.join(OUTPUT_DIR, 'shiptracker.lnk.kml'))
print('... shiptracker.lnk.kml SAVED!!')
def make_lines_pmarks(lines, settings):
pmarks,styles = [],[]
for name,line in lines.items():
path = kml.LineString(line)
styleUrl= 'PATH_STYLE_'+name
try: color = possible_custom_setting(name, 'color', settings)
except: color = 'white'
color = kml.HEXCOLOR[color.lower()]
style=kml.Style(id=styleUrl, LineStyle=kml.LineStyle(color))
pmark = kml.Placemark(name=name,
geometry=path,
styleUrl=styleUrl )
pmarks.append(pmark)
styles.append(style)
return pmarks, styles
def make_mooring_pmarks(moorings, settings):
pmarks,styles = [],[]
for mooring in sorted(moorings.values(), key=lambda m: m['name']):
point = kml.Point(lat=mooring['lat'],
lon=mooring['lon'])
# assemble mooring icon
iconURL = possible_custom_setting(mooring['name'], 'mooring_icon', settings)
styleUrl = 'MOORING_STYLE_'+iconURL[iconURL.rindex('/')+1:]
style = kml.Style(IconStyle=kml.IconStyle(iconhref=iconURL,scale=1.2,
hotSpot = kml.IconStyle.hotSpot(y=0.05)), #put icon anchor near bottom center
BalloonStyle=kml.BalloonStyle(None),
id=styleUrl)
lookat = kml.LookAt(range=230000,lat=mooring['lat'],lon=mooring['lon'])
p = kml.Placemark(name=mooring['name'],
geometry=point,
LookAt = lookat,
styleUrl=styleUrl)
pmarks.append(p)
styles.append(style)
styles = list(set(styles))
return pmarks,styles
def main(configs, output_kml_file):
array_folders = []
styles = []
for array in sorted(configs, key=lambda arr: arr['name']):
print(' '+array['name'].upper().strip())
# CREATE KML PLACEMARKS AND STYLES #
lines_pmarks, \
lines_styles = make_lines_pmarks(array['lines'], array['settings'])
mooring_pmarks,\
mooring_styles = make_mooring_pmarks(array['moorings'], array['settings'])
glider_pmarks,\
glider_surfacings,\
glider_trails,\
glider_wpts,\
glider_argos,\
glider_styles = make_glider_features(array['gliders'],array['settings'])
# CREATE FOLDER STRUCTURE #
if array['settings']['show_by_default']:
array_folder = kml.Folder(name=array['name'], open=1)
else:
array_folder = kml.Folder(name=array['name'], visibility=0)
more_folder = kml.Folder(name='more...',
style=kml.Style(ListStyle=kml.checkOffOnly_ListStyle))
surfacings_folders = []
argos_folders = []
for glider in glider_pmarks:
if glider_surfacings:
surfacings_folder = kml.Folder(name=glider.name + " Surfacings")
surfacings_folders.append(surfacings_folder)
if glider_argos:
argos_folder = kml.Folder(name=glider.name +" Argos", visibility=0)
argos_folders.append(argos_folder)
# hotpatch quickfix #
# no next-wpt or surfacings for archive #
if array['settings']['file_name'] == 'archive.kml':
glider_wpts, glider_surfacings, surfacings_folders = [], [], []
more_folder = kml.Folder(name='more...')
# FILLING FOLDERS WITH PLACEMARKS # ##ARCHIVE ARRAY MODE
array_folder.extend(glider_pmarks)
array_folder.extend(mooring_pmarks)
array_folder.append(more_folder)
more_folder.extend(glider_wpts)
more_folder.extend(glider_trails)
more_folder.extend(surfacings_folders)
more_folder.extend(lines_pmarks)
##more_folder.extend(glider_pmarks)
##more_folder.extend(surfacings_folders)
for i, glider in enumerate(glider_pmarks):
if surfacings_folders: surfacings_folders[i].extend(glider_surfacings[i])
if glider_argos: argos_folders[i].extend(glider_argos[i])
##array_folder.extend(glider_trails)
##array_folder.append(more_folder)
array_folders.append(array_folder)
styles.extend(mooring_styles + glider_styles + lines_styles)
#print('TOTAL_STYLES list:', len(styles), ' set:', len(set(styles)))
# remove duplicates and sort kml's shared styles
styles = sorted(list(set(styles)))
# Assembly of all Features and Containers into the full document
doc = kml.kml(kml.Document(*styles + array_folders, open=1))
# outputting the doc!
if output_kml_file:
doc.save(output_kml_file)
print(output_kml_file, '...done!')
else:
doc.pprint()
## CREATE NETWORK LINK FILE IF NETLINK SETTING SET
try:
# We don't want the network link to load a monstrous amount of data all at once
if any([array['settings']['show_by_default'] is False for array in configs]):
chekov_style = kml.Style(ListStyle=kml.checkOffOnly_ListStyle)
else: chekov_style = None
targetURL = config[0]['settings']['netlink']
netdoc = kml.kml(kml.NetworkLink(kml.Link(targetURL, refreshInterval=60),
chekov_style))
doti = output_kml_file.rindex('.')
output_netlink_file = output_kml_file[:doti] + '.lnk' + output_kml_file[doti:]
netdoc.save(output_netlink_file)
print(output_netlink_file, '...done!')
except KeyError: pass
except Exception as e: print('make netlink:',type(e),e)
def make_glider_features(gliders,settings):
glider_pmarks, glider_surfacings, glider_trails, glider_wpts, glider_argos, styles = [],[],[],[],[],[]
for glider in sorted(gliders.values(), key=lambda g: g['name']):
print(' '+glider['name'])
gstate_path = os.path.join(settings['datapath'],glider['refdes'],'gliderState.xml')
try:
try: coords, script, wpt, lastabort = gsx.parse(gstate_path)
except ValueError:
coords, script, wpt, lastabort = gsx.alt_parse(gstate_path)
except FileNotFoundError:
coords, script, wpt, lastabort = gsx.alt_parse(gstate_path)
except Exception as e:
print('make_glider_feature() error',type(e),e)
continue
except FileNotFoundError as e1:
print('FNFE:',e1)
continue
except IndexError as e1:
print('FNFE:',e1)
continue
### hack to remove one known bad datapoint from one glider ###
if glider['name'] == 'ga_578':
for coord in coords:
if int(coord['lon']) == -144 and int(coord['lat']) == 50:
coords.remove(coord)
break
### GLIDER PMARK ###
t = coords[-1]['epoch']
if wpt is None: bearing = None
else: bearing = wpt['bearing']
style,styleUrl = get_glider_icon_style(settings, bearing, glider['name'],t)
desc = glider_desc(glider,coords[-1],script,lastabort)
lookat = kml.LookAt(lat=coords[-1]['lat'],lon=coords[-1]['lon'],range=230000)
pmark = kml.Placemark(name=glider['name'], # last coord is most recent
geometry=kml.Point(lat=coords[-1]['lat'],
lon=coords[-1]['lon']),
styleUrl=styleUrl,
description=desc,
LookAt=lookat,
Snippet=kml.Snippet(None))
glider_pmarks.append(pmark)
styles.append(style)
### GLIDER SURFACINGS ###
surfmarks = []
iconURL = possible_custom_setting(glider['name'], 'glider_icon_surf', settings)
surfacing_style_mousover = kml.Style(IconStyle=kml.IconStyle(iconhref=iconURL, scale=0.8),
BalloonStyle=kml.BalloonStyle(None))
surfacing_style_normal = kml.Style(IconStyle=kml.IconStyle(iconhref=iconURL, scale=0.2),
LabelStyle=kml.LabelStyle(scale=0))
styleUrl = 'Surfacing_'+iconURL
surfacing_style = kml.StyleMap(styleUrl, surfacing_style_normal, surfacing_style_mousover)
styles.append(surfacing_style)
limit = det_tail_length(settings, 'tail_length', glider['name'], coords)
for coord in coords[-limit:-1]:
surface_dialogue_count = coord['dupes']
name = '{} {}'.format(glider['name'], coord['timestamp'])
if possible_custom_setting(glider['name'],'time_scrolling',settings):
ts = kml.TimeStamp(coord['epoch'])
else: ts = None
surfmark = kml.Placemark(name=name, styleUrl=surfacing_style.id,
geometry=kml.Point(lat=coord['lat'],
lon=coord['lon']),
time = ts)
surfmarks.append(surfmark)
glider_surfacings.append(surfmarks)
### GLIDER TRAIL ###
styleUrl = 'gtrail'
limit = det_tail_length(settings, 'tail_length', glider['name'], coords)
style = kml.Style(id=styleUrl, LabelStyle=kml.LabelStyle(scale=0),
LineStyle=kml.LineStyle(kml.HEXCOLOR['yellow']))
styles.append(style)
time_scrolling = possible_custom_setting(glider['name'],'time_scrolling',settings)
trailmark = kml.Placemark(name = glider['name']+' Trail',
styleUrl=styleUrl,
geometry=kml.LineString(coords[-limit:]))
glider_trails.append(trailmark)
# # TIME TRAILS are not really working, probably due to glidertrails not being properly injested later
# for i in range(len(coords[-limit:])-1):
# geom = kml.LineString(coords[i:i+3]) # returns two consecutive coords
# tspan = kml.TimeSpan(coords[i]['epoch'],coords[i+1]['epoch'])
# trailmark = kml.Placemark(name=glider['name'] + ' Trail' + str(i),
# styleUrl=styleUrl,
# geometry=geom,
# time=tspan)
# glider_trails.append(trailmark)
### GLIDER WPT ###
if wpt is None:
glider_wpts.append(None)
else:
name="{}'s Next Waypoint".format(glider['name'])
desc = kml.xml('pre','Lat:{:+.3f}\nLon:{:+.3f}'.format(wpt['lat'],wpt['lon']))
iconURL = possible_custom_setting(glider['name'], 'nextwpt_icon', settings)
styleUrl = 'NextWpt_'+iconURL
nextwpt_style_mouseover = kml.Style(IconStyle=kml.IconStyle(iconhref=iconURL),
BalloonStyle=kml.BalloonStyle(None))
nextwpt_style_normal = kml.Style(IconStyle=kml.IconStyle(iconhref=iconURL),
LabelStyle=kml.LabelStyle(scale=0))
nextwpt_style = kml.StyleMap(styleUrl, nextwpt_style_normal, nextwpt_style_mouseover)
styles.append(nextwpt_style)
wptmark = kml.Placemark(styleUrl=nextwpt_style.id, name=name, description=desc,
geometry=kml.Point(lat=wpt['lat'],lon=wpt['lon']),
Snippet=kml.Snippet(None))
glider_wpts.append(wptmark)
### GLIDER ARGOS ###
if settings['argos_src']:
argos_hits = argos_parser.main(settings['argos_src'],glider['name'])
argos_pmarks = []
iconURL = possible_custom_setting(glider['name'], 'argos_icon', settings)
argos_style = kml.Style(id='Argos_'+iconURL,
IconStyle=kml.IconStyle(iconhref=iconURL, scale=1),
LabelStyle=kml.LabelStyle(scale=0),
BalloonStyle=kml.BalloonStyle(None))
styles.append(argos_style)
start_limit = det_tail_length(settings, 'argos_start', glider['name'], argos_hits)
end_limit = det_tail_length(settings, 'argos_end', glider['name'], argos_hits)
for argos_hit in argos_hits[-start_limit:-end_limit]:
argos_pmark = kml.Placemark(name=glider['name']+' Argos_Hit '+argos_hit['timestamp'],
styleUrl=argos_style.id, visibility = 0,
description = argos_hit['desc'],
Snippet = kml.Snippet(None),
geometry=kml.Point(lat=argos_hit['lat'],
lon=argos_hit['lon']))
argos_pmarks.append(argos_pmark)
glider_argos.append(argos_pmarks)
styles = list(set(styles))
return glider_pmarks, glider_surfacings, glider_trails, glider_wpts, glider_argos, styles