def polygon_from_aggregate(layer_title, point, max_num_responses):
""" Make a polygon-based kml.Placemark from an AggregatePoint containing
boolean data."""
lat = point.lat
lon = point.lon
summary = _BooleanSummary(point)
if summary.count == 0:
return kml.Placemark('No Data', 'No Data', kml.Polygon([(lat, lon)]))
desc = '%s\n%s responses. %s affirmative' % (layer_title, summary.count,
summary.percent_true)
percent_of_total_responses = summary.count/ float(max_num_responses)
min_circle_size = 0.025
circle_scale = .15
num_segments = 32
radius = percent_of_total_responses * circle_scale + min_circle_size
points = []
for n in range(num_segments):
rad = 2 * math.pi * n / num_segments
points.append((lat + (math.cos(rad) * radius),
lon + (math.sin(rad) * radius)))
points.append(points[0]) # Make last == first
polygon = kml.Polygon(points)
p = kml.Placemark('%s/%s' % (summary.true, summary.count), desc, polygon)
red, green, blue, alpha = list(make_boolean_pixel(point))
alpha = 255
colors = (alpha, blue, green, red) # KML does colors backwards.
p.style = kml.PolyStyle(''.join('%02x' % x for x in colors))
return p
def make_animation(self, globals):
icon_style = kml.IconStyle(globals.stock.animation_icon,
color=self.color,
scale=globals.stock.icon_scales[0])
list_style = kml.ListStyle(listItemType='checkHideChildren')
style = kml.Style(icon_style, list_style)
folder = kml.Folder(style, name='Animation', visibility=0)
point = kml.Point(coordinates=[self.track.coords[0]],
altitudeMode=self.altitude_mode)
timespan = kml.TimeSpan(end=kml.dateTime(self.track.coords[0].dt))
placemark = kml.Placemark(point, timespan, styleUrl=style.url())
folder.add(placemark)
for i in xrange(1, len(self.track.coords)):
coord = self.track.coords[i - 1].halfway_to(self.track.coords[i])
point = kml.Point(coordinates=[coord],
altitudeMode=self.altitude_mode)
begin = kml.dateTime(self.track.coords[i - 1].dt)
end = kml.dateTime(self.track.coords[i].dt)
timespan = kml.TimeSpan(begin=begin, end=end)
placemark = kml.Placemark(point, timespan, styleUrl=style.url())
folder.add(placemark)
point = kml.Point(coordinates=[self.track.coords[-1]],
altitudeMode=self.altitude_mode)
timespan = kml.TimeSpan(begin=kml.dateTime(self.track.coords[-1].dt))
placemark = kml.Placemark(point, timespan, styleUrl=style.url())
folder.add(placemark)
return kmz.kmz(folder)
def placemark_from_aggregate(layer_title, point, max_num_responses):
""" Make a placemark from an AggregatePoint containing numeric data."""
count = len(point)
if count == 0:
return kml.Placemark('No Data', 'No Data',
kml.Point(point.lat, point.lon))
values = [p.value for p in point]
avg = int(sum(values) / float(count))
med = int(sorted(values)[count / 2])
desc = '%s responses\nAverage: %s\nMedian: %s' % (count, avg, med)
p = kml.Placemark('%s/%s' % (avg, med), desc,
kml.Point(point.lat, point.lon))
scale = (count / float(max_num_responses)) * 1.5 + 0.8
p.style = kml.Style(kml.WHITE_PIN, scale)
return p
def make_leg(route, i, j, name=True, arrow=False, style_url=None):
coord0 = route.tps[i].coord
coord1 = route.tps[j].coord
line_string = kml.LineString(coordinates=[coord0, coord1],
altitudeMode='clampToGround',
tessellate=1)
multi_geometry = kml.MultiGeometry(line_string)
if name:
point = kml.Point(coordinates=[coord0.halfway_to(coord1)])
multi_geometry.add(point)
distance = coord0.distance_to(coord1)
name = kml.name('%.1fkm' % (distance / 1000.0))
if arrow:
bearing = coord1.initial_bearing_to(coord0)
coordinates = [
coord1.coord_at(bearing - pi / 12.0, 400.0), coord1,
coord1.coord_at(bearing + pi / 12.0, 400.0)
]
line_string = kml.LineString(coordinates=coordinates,
altitudeMode='clampToGround',
tessellate=1)
multi_geometry.add(line_string)
if style_url is None:
style_url = globals.stock.xc_style.url()
return kml.Placemark(name, multi_geometry, styleUrl=style_url)
def make_photos_folder(self, globals):
if not len(self.photos):
return kmz.kmz()
folder = kml.Folder(name='Photos', open=0)
for photo in sorted(self.photos, key=operator.attrgetter('dt')):
if photo.coord:
coord = photo.coord
if photo.elevation_data:
altitude_mode = 'absolute'
else:
altitude_mode = 'clampToGround'
else:
coord = self.track.coord_at(photo.dt - globals.tz_offset)
altitude_mode = self.altitude_mode
point = kml.Point(coordinates=[coord], altitudeMode=altitude_mode)
if photo.description:
title = '%s: %s' % (photo.name, photo.description)
else:
title = photo.name
description = '<h3>%s</h3>%s' % (title, photo.to_html_img())
style_url = globals.stock.photo_style.url()
placemark = kml.Placemark(point,
name=photo.name,
description=kml.CDATA(description),
Snippet=kml.CDATA(description),
styleUrl=style_url)
folder.add(placemark)
return kmz.kmz(folder)
def make_colored_track(self, globals, values, scale, altitude_mode,
scale_chart=True, **folder_options):
style_url = globals.stock.check_hide_children_style.url()
folder = kml.Folder(name='Colored by %s' % scale.title,
styleUrl=style_url, **folder_options)
styles = [kml.Style(kml.LineStyle(color=color, width=self.width))
for color in scale.colors()]
discrete_values = map(scale.discretize, values)
for sl in util.runs(discrete_values):
coordinates = self.track.coords[sl.start:sl.stop + 1]
line_string = kml.LineString(coordinates=coordinates,
altitudeMode=self.altitude_mode)
style_url = kml.styleUrl(styles[discrete_values[sl.start]].url())
placemark = kml.Placemark(style_url, line_string)
folder.add(placemark)
if scale_chart:
href = self.make_scale_chart(globals, scale).get_url()
icon = kml.Icon(href=kml.CDATA(href))
overlay_xy = kml.overlayXY(x=0, xunits='fraction',
y=1, yunits='fraction')
screen_xy = kml.screenXY(x=0, xunits='fraction',
y=1, yunits='fraction')
size = kml.size(x=0, xunits='fraction', y=0, yunits='fraction')
screen_overlay = kml.ScreenOverlay(icon, overlay_xy, screen_xy, size)
folder.add(screen_overlay)
return kmz.kmz(folder).add_roots(*styles)
def placemark_from_aggregate(layer_title, point, max_num_responses):
""" Make a point-based kml.Placemark from an AggregatePoint containing
boolean data."""
summary = _BooleanSummary(point)
if summary.count == 0:
return kml.Placemark('No Data', 'No Data', kml.Point(point.lat, point.lon))
desc = '%s\n%s responses. %s affirmative' % (layer_title, summary.count,
summary.percent_true)
p = kml.Placemark('%s/%s' % (summary.true, summary.count), desc,
kml.Point(point.lat, point.lon))
scale = (summary.count/ float(max_num_responses)) * 1.5 + 0.8
if summary.true_false_ratio > 0.5:
style = kml.Style(kml.BLUE_PIN, scale)
else:
style = kml.Style(kml.RED_PIN, scale)
p.style = style
return p
def make_solid_track(self, globals, style, altitude_mode, extrude=None,
**folder_options):
line_string = kml.LineString(coordinates=self.track.coords,
altitudeMode=altitude_mode)
if extrude:
line_string.add(extrude=1)
placemark = kml.Placemark(style, line_string)
style_url = globals.stock.check_hide_children_style.url()
folder_options['styleUrl'] = style_url
return kmz.kmz(kml.Folder(placemark, **folder_options))
def make_placemark(self,
globals,
coord,
altitudeMode=None,
name=None,
style_url=None):
point = kml.Point(coordinates=[coord], altitudeMode=altitudeMode)
return kml.Placemark(point,
name=name,
Snippet=None,
styleUrl=style_url)
def make_tour_folder(self, globals):
style_url = globals.stock.check_hide_children_style.url()
folder = kmz.kmz(kml.Folder(name='Tour', styleUrl=style_url))
dt = self.track.coords[0].dt
delta = datetime.timedelta(seconds=15 * 60)
coords = []
while dt < self.track.coords[-1].dt:
coords.append(self.track.coord_at(dt))
dt += delta
for i in xrange(0, len(coords)):
j = (i + 1) % len(coords)
point = kml.Point(coordinates=[coords[i]], altitudeMode=self.altitude_mode)
heading = coords[i].initial_bearing_to_deg(coords[j])
camera = kml.Camera(altitude=coords[i].ele, heading=heading,
latitude=coords[i].lat_deg,
longitude=coords[i].lon_deg, tilt=75)
placemark = kml.Placemark(point, camera)
folder.add(placemark)
return folder
def make_task_folder(globals, task):
name = task.name or 'Task'
rows = []
tp0 = None
total = 0.0
count = -1
for sl in util.runs([tp.name for tp in task.tps]):
if tp0 is None:
tp0 = task.tps[sl.start]
continue
tp1 = task.tps[sl.stop - 1]
distance = tp0.coord.distance_to(tp1.coord)
th = '%s %s %s' % (tp0.name, RIGHTWARDS_ARROW, tp1.name)
td = '%.1fkm' % (distance / 1000.0)
rows.append((th, td))
total += distance
count += 1
tp0 = tp1
rows.append(('Total', '%.1fkm' % (total / 1000.0)))
table = make_table(rows)
snippet = '%.1fkm via %d turnpoints' % (total / 1000.0, count)
style_url = globals.stock.check_hide_children_style.url()
folder = kml.Folder(name=name,
description=kml.CDATA(table),
Snippet=snippet,
styleUrl=style_url)
style_url = globals.stock.xc_style.url()
done = set()
for tp in task.tps:
key = tp.name
if key in done:
continue
else:
done.add(key)
point = kml.Point(coordinates=[tp.coord])
folder.add(kml.Placemark(point, name=tp.name, styleUrl=style_url))
done = set()
for tp in task.tps:
if tp.radius == 0:
continue
key = (tp.name, tp.radius)
if key in done:
continue
else:
done.add(key)
coordinates = kml.coordinates.circle(tp.coord, tp.radius)
line_string = kml.LineString(coordinates, tessellate=1)
folder.add(kml.Placemark(line_string, styleUrl=style_url))
tp0 = None
for sl in util.runs([tp.name for tp in task.tps]):
if tp0 is None:
tp0 = task.tps[sl.start]
continue
tp1 = task.tps[sl.stop - 1]
coord0 = tp0.coord.coord_at(tp0.coord.initial_bearing_to(tp1.coord),
tp0.radius)
theta = tp1.coord.initial_bearing_to(tp0.coord)
coord1 = tp1.coord.coord_at(theta, tp1.radius)
line_string1 = kml.LineString(coordinates=[coord0, coord1],
tessellate=1)
coords = [
coord1.coord_at(theta - pi / 12.0, 400.0), coord1,
coord1.coord_at(theta + pi / 12.0, 400.0)
]
line_string2 = kml.LineString(coordinates=coords, tessellate=1)
multi_geometry = kml.MultiGeometry(line_string1, line_string2)
folder.add(kml.Placemark(multi_geometry, styleUrl=style_url))
tp0 = tp1
return kmz.kmz(folder)
def make_time_mark(self, globals, coord, dt, style_url):
point = kml.Point(coordinates=[coord], altitudeMode=self.altitude_mode)
name = (dt + globals.tz_offset).strftime('%H:%M')
return kml.Placemark(point, name=name, styleUrl=style_url)
def make_analysis_folder(self, globals, title, slices, style_url):
if not self.track.elevation_data or len(slices) == 0:
return kmz.kmz()
folder_style_url = globals.stock.check_hide_children_style.url()
folder = kml.Folder(name=title.capitalize() + "s",
styleUrl=folder_style_url,
visibility=0)
for sl in slices:
coord0 = self.track.coords[sl.start]
coord1 = self.track.coords[sl.stop]
coord = coord0.halfway_to(coord1)
point = kml.Point(coordinates=[coord], altitudeMode='absolute')
total_dz_positive = total_dz_negative = 0
peak_climb = util.Bounds(0.0)
for i in xrange(sl.start, sl.stop):
dz = self.track.coords[i + 1].ele - self.track.coords[i].ele
dt = self.track.t[i + 1] - self.track.t[i]
if dz > 0:
total_dz_positive += dz
elif dz < 0:
total_dz_negative += dz
peak_climb.update(float(dz) / dt)
climb = util.Bounds(self.track.climb[sl])
dz = float(self.track.coords[sl.stop].ele -
self.track.coords[sl.start].ele)
dt = self.track.t[sl.stop] - self.track.t[sl.start]
dp = coord0.distance_to(coord1)
theta = coord0.initial_bearing_to(coord1)
dict = {}
dict['altitude_change'] = int(round(dz))
dict['average_climb'] = round(dz / dt, 1)
dict['maximum_climb'] = round(climb.max, 1)
dict['peak_climb'] = round(peak_climb.max, 1)
divisor = dt * climb.max
if divisor == 0:
dict['efficiency'] = UP_TACK
else:
dict['efficiency'] = int(round(100.0 * dz / divisor))
dict['distance'] = round(dp / 1000.0, 1)
average_ld = round(-dp / dz, 1) if dz < 0 else INFINITY
dict['average_ld'] = average_ld
dict['average_speed'] = round(3.6 * dp / dt, 1)
dict['maximum_descent'] = round(climb.min, 1)
dict['peak_descent'] = round(peak_climb.min, 1)
dict['start_altitude'] = coord0.ele
dict['finish_altitude'] = coord1.ele
start_time = coord0.dt + globals.tz_offset
dict['start_time'] = start_time.strftime('%H:%M:%S')
stop_time = coord1.dt + globals.tz_offset
dict['finish_time'] = stop_time.strftime('%H:%M:%S')
duration = self.track.t[sl.stop] - self.track.t[sl.start]
dict['duration'] = '%dm %02ds' % divmod(duration, 60)
dict['accumulated_altitude_gain'] = total_dz_positive
dict['accumulated_altitude_loss'] = total_dz_negative
dict['drift_direction'] = rad_to_cardinal(theta + pi)
extended_data = kml.ExtendedData.dict(dict)
if title == 'thermal':
name = '%dm at %.1fm/s' % (dz, dz / dt)
elif title == 'glide':
name = '%.1fkm at %s:1, %dkm/h' \
% (dp / 1000.0, average_ld, round(3.6 * dp / dt))
elif title == 'dive':
name = '%dm at %.1fm/s' % (-dz, dz / dt)
placemark = kml.Placemark(point,
extended_data,
name=name,
Snippet=None,
styleUrl=style_url)
folder.add(placemark)
line_string = kml.LineString(coordinates=[coord0, coord1],
altitudeMode='absolute')
placemark = kml.Placemark(line_string, styleUrl=style_url)
folder.add(placemark)
return kmz.kmz(folder)
def make_xc_folder(self, globals):
def make_row(route, i, j, percentage=False):
distance = route.tps[i].coord.distance_to(route.tps[j].coord)
th = '%s %s %s' \
% (route.tps[i].name, RIGHTWARDS_ARROW, route.tps[j].name)
if percentage:
td = '%.1fkm (%.1f%%)' \
% (distance / 1000.0, 0.1 * distance / route.distance)
else:
td = '%.1fkm' % (distance / 1000.0)
return (th, td)
def make_leg(route, i, j, name=True, arrow=False, style_url=None):
coord0 = route.tps[i].coord
coord1 = route.tps[j].coord
line_string = kml.LineString(coordinates=[coord0, coord1],
altitudeMode='clampToGround',
tessellate=1)
multi_geometry = kml.MultiGeometry(line_string)
if name:
point = kml.Point(coordinates=[coord0.halfway_to(coord1)])
multi_geometry.add(point)
distance = coord0.distance_to(coord1)
name = kml.name('%.1fkm' % (distance / 1000.0))
if arrow:
bearing = coord1.initial_bearing_to(coord0)
coordinates = [
coord1.coord_at(bearing - pi / 12.0, 400.0), coord1,
coord1.coord_at(bearing + pi / 12.0, 400.0)
]
line_string = kml.LineString(coordinates=coordinates,
altitudeMode='clampToGround',
tessellate=1)
multi_geometry.add(line_string)
if style_url is None:
style_url = globals.stock.xc_style.url()
return kml.Placemark(name, multi_geometry, styleUrl=style_url)
if not self.xc:
return kmz.kmz()
style_url = globals.stock.radio_folder_style.url()
folder = kml.Folder(name='Cross country', open=0, styleUrl=style_url)
folder.add(globals.stock.invisible_none_folder)
for rank, route in enumerate(
sorted(self.xc.routes,
key=operator.attrgetter('score'),
reverse=True)):
rows = []
rows.append(('League', route.league))
rows.append(('Type', route.name[0].upper() + route.name[1:]))
if route.circuit:
if len(route.tps) == 4:
rows.append(make_row(route, 1, 2))
rows.append(make_row(route, 2, 1))
else:
for i in xrange(1, len(route.tps) - 2):
rows.append(make_row(route, i, i + 1, percentage=True))
rows.append(make_row(route, -2, 1, percentage=True))
else:
for i in xrange(0, len(route.tps) - 1):
rows.append(make_row(route, i, i + 1))
rows.append(('Distance', '%.1fkm' % route.distance))
rows.append(('Multiplier', '%s %.2f points/km' %
(MULTIPLICATION_SIGN, route.multiplier)))
rows.append(('Score', '<b>%.2f points</b>' % route.score))
speed = 3600.0 * route.distance \
/ (route.tps[-1].coord.dt - route.tps[0].coord.dt).seconds
rows.append(('Average speed', '%.1fkm/h' % speed))
if route.circuit:
rows.append(make_row(route, -1, 0))
table = make_table(rows)
name = '%.1fkm %s (%.2f points)' \
% (route.distance, route.name, route.score)
visibility = 1 if rank == 0 else 0
style_url = globals.stock.check_hide_children_style.url()
route_folder = kml.Folder(name=name,
description=kml.CDATA(table),
Snippet=None,
styleUrl=style_url,
visibility=visibility)
for tp in route.tps:
coord = self.track.coord_at(tp.coord.dt)
point = kml.Point(coordinates=[coord],
altitudeMode=self.altitude_mode,
extrude=1)
style_url = globals.stock.xc_style.url()
placemark = kml.Placemark(point,
name=tp.name,
styleUrl=style_url)
route_folder.add(placemark)
if route.circuit:
route_folder.add(make_leg(route, 0, 1, name=None, arrow=True))
if len(route.tps) == 4:
route_folder.add(make_leg(route, 1, 2))
else:
for i in xrange(1, len(route.tps) - 2):
route_folder.add(make_leg(route, i, i + 1, arrow=True))
style_url = globals.stock.xc_style2.url()
route_folder.add(
make_leg(route, -2, 1, style_url=style_url))
route_folder.add(make_leg(route, -2, -1, name=None,
arrow=True))
else:
for i in xrange(0, len(route.tps) - 1):
route_folder.add(make_leg(route, i, i + 1, arrow=True))
folder.add(route_folder)
return kmz.kmz(folder)
