def draw(self, referential_race_name, comparison_race_name, segment_type, filename):
"""Draw both races and the corresponding best segment"""
race_manager = self.race_inferer.race_manager
referential_race = race_manager.races[referential_race_name]
comparison_race = race_manager.races[comparison_race_name]
deniv_segment, length_segment, density_segment = self.get_best_segment(referential_race_name)
segments = deniv_segment + length_segment + density_segment
segment = None
for segment_tuple in segments:
if segment_tuple[0] == comparison_race_name and segment_tuple[1].segment_type == segment_type:
segment = segment_tuple[1]
break
if GOOGLE_MAP_API_KEY is None:
gmap3 = GoogleMapPlotter(46.98, 6.89, 14)
else:
gmap3 = GoogleMapPlotter(46.98, 6.89, 14, apikey=GOOGLE_MAP_API_KEY)
gmap3.plot(referential_race.df.position_lat, referential_race.df.position_long, 'cornflowerblue',
edge_width=2.5)
gmap3.plot(comparison_race.df.position_lat, comparison_race.df.position_long, 'limegreen',
edge_width=2.5)
segment.draw('red', gmap3)
gmap3.draw(filename)
def checkGridCoord(lat_origin, lon_origin, lat, lon):
initial_zoom = 12
apikey = 'AIzaSyAZ_VZXoJULTFQ9KSPg1ClzHEFjyPbJUro'
gmap = GoogleMapPlotter(lat_origin,
lon_origin,
initial_zoom,
map_type='satellite',
apikey=apikey)
gmap.scatter(lat, lon, color='#99ff00', size=20, marker=False)
gmap.draw(
"/Users/yaoling/OneDrive - NTNU/MASCOT_PhD/Missions/MapPlot/map.html"
)
def checkBox(self):
from gmplot import GoogleMapPlotter
initial_zoom = 12
apikey = 'AIzaSyAZ_VZXoJULTFQ9KSPg1ClzHEFjyPbJUro'
gmap = GoogleMapPlotter(self.lat_origin,
self.lon_origin,
initial_zoom,
map_type='satellite',
apikey=apikey)
gmap.scatter(self.box[:, 0], self.box[:, 1], 'cornflowerblue', size=10)
gmap.draw(
"/Users/yaoling/OneDrive - NTNU/MASCOT_PhD/Missions/MapPlot/map.html"
)
def plotGridonMap(self, grid):
def color_scatter(gmap,
lats,
lngs,
values=None,
colormap='coolwarm',
size=None,
marker=False,
s=None,
**kwargs):
def rgb2hex(rgb):
""" Convert RGBA or RGB to #RRGGBB """
rgb = list(rgb[0:3]) # remove alpha if present
rgb = [int(c * 255) for c in rgb]
hexcolor = '#%02x%02x%02x' % tuple(rgb)
return hexcolor
if values is None:
colors = [None for _ in lats]
else:
cmap = plt.get_cmap(colormap)
norm = Normalize(vmin=min(values), vmax=max(values))
scalar_map = ScalarMappable(norm=norm, cmap=cmap)
colors = [
rgb2hex(scalar_map.to_rgba(value)) for value in values
]
for lat, lon, c in zip(lats, lngs, colors):
gmap.scatter(lats=[lat],
lngs=[lon],
c=c,
size=size,
marker=marker,
s=s,
**kwargs)
initial_zoom = 12
apikey = 'AIzaSyAZ_VZXoJULTFQ9KSPg1ClzHEFjyPbJUro'
gmap = GoogleMapPlotter(grid[0, 0],
grid[0, 1],
initial_zoom,
apikey=apikey)
color_scatter(gmap,
grid[:, 0],
grid[:, 1],
np.zeros_like(grid[:, 0]),
size=20,
colormap='hsv')
gmap.draw(
"/Users/yaoling/OneDrive - NTNU/MASCOT_PhD/Missions/MapPlot/map.html"
)
def draw(self, color='cornflowerblue', gmap3=None):
if gmap3 is None:
if GOOGLE_MAP_API_KEY is None:
gmap3 = GoogleMapPlotter(46.98, 6.89, 14)
else:
gmap3 = GoogleMapPlotter(46.98,
6.89,
14,
apikey=GOOGLE_MAP_API_KEY)
gmap3.plot(self.df.position_lat,
self.df.position_long,
color,
edge_width=2.5)
filename = os.path.join(st.files["output_folder"], f"{self.name}.html")
gmap3.draw(filename)
def checkGridCoord(self):
from gmplot import GoogleMapPlotter
initial_zoom = 12
apikey = 'AIzaSyAZ_VZXoJULTFQ9KSPg1ClzHEFjyPbJUro'
gmap = GoogleMapPlotter(self.lat_origin,
self.lon_origin,
initial_zoom,
map_type='satellite',
apikey=apikey)
gmap.scatter(self.grid_coord[:, 0],
self.grid_coord[:, 1],
color='#99ff00',
size=20,
marker=False)
gmap.draw(
"/Users/yaoling/OneDrive - NTNU/MASCOT_PhD/Missions/MapPlot/map.html"
)
def draw(self):
if self.density_segment is None or self.length_segment is None or self.deniv_segment is None:
print("Need to call all 3 get_..._segment before draw()")
return -1
if GOOGLE_MAP_API_KEY is None:
gmap3 = GoogleMapPlotter(46.98, 6.89, 14)
else:
gmap3 = GoogleMapPlotter(46.98, 6.89, 14, apikey=GOOGLE_MAP_API_KEY)
self.length_segment.draw('purple', gmap3=gmap3)
self.density_segment.draw('red', gmap3=gmap3)
self.deniv_segment.draw('yellow', gmap3=gmap3)
filename = os.path.join(st.files["output_folder"], f"best_segment_{self.referential_race_name}.html")
gmap3.draw(filename)
return 0
def draw(self):
if GOOGLE_MAP_API_KEY is None:
gmap3 = GoogleMapPlotter(46.98, 6.89, 14)
else:
gmap3 = GoogleMapPlotter(46.98,
6.89,
14,
apikey=GOOGLE_MAP_API_KEY)
self.race1.draw(color='cornflowerblue', gmap3=gmap3)
self.race2.draw(color='limegreen', gmap3=gmap3)
# Plot segment
for segment in self.segments:
segment.draw(color='red', gmap3=gmap3)
output_folder = st.files["output_folder"]
filename = f'{output_folder}/{self.name}.html'
gmap3.draw(filename)
pl_lat.append(latitude)
po_scatter_path = (po_lat,po_lon)
pl_scatter_path = (pl_lat,pl_lon)
if (city is 'US'):
mymap = GoogleMapPlotter(39.908213, -99.675441, 4)
else:
mymap = GoogleMapPlotter.from_geocode(city, 12)
lat, lng = mymap.geocode(city)
for group in ultralist:
drawGroupBox(group,mymap)
mymap.scatter(po_scatter_path[0], po_scatter_path[1], c='tomato', marker=True)
mymap.scatter(pl_scatter_path[0], pl_scatter_path[1], c='lemonchiffon', marker=True)
mymap.draw('./mymap.html')
webbrowser.open(tweetMap)
if (searchType == 'real'):
startDate = raw_input('Enter todays date: ')
while True:
for tweet in DB:
date = DB[tweet][u'created_at']
place = DB[tweet]['place']['place_type']
category = DB[tweet]['classification']
if (startDate in date):
startFound = True
if (startFound):
def segment_density(self, referential_race_name, verbose=0):
all_segments = list(self.all_seg_of_one_race[referential_race_name])
points = np.array(all_segments[0].positions[:2, :])
for segment in all_segments[1:]:
try:
points = np.append(points, segment.positions[:2, :], axis=1)
except:
print("Probably zero size array...")
max_lat = np.max(points[0, :])
max_long = np.max(points[1, :])
min_lat = np.min(points[0, :])
min_long = np.min(points[1, :])
delta = 0.0005 # degré
lat = np.arange(min_lat, max_lat, delta)
long = np.arange(min_long, max_long, delta)
density = np.zeros([3, lat.shape[0] * long.shape[0]]) # [lat,long,nbpoint]
i = 0
for x in lat:
for y in long:
# parcours et remplissage de la "grid" de densité
density[0, i] = x
density[1, i] = y
for segment in all_segments:
seg = segment.positions
x_less = np.where(seg[0, :] >= (x - delta / 2))
x_more = np.where(seg[0, :] < (x + delta / 2))
count_x = np.intersect1d(x_less, x_more)
y_less = np.where(seg[1, :] >= (y - delta / 2))
y_more = np.where(seg[1, :] < (y + delta / 2))
count_y = np.intersect1d(y_less, y_more)
valid_coordinate = np.intersect1d(count_x, count_y).shape[0]
if valid_coordinate > 0:
# on ajoute 1 si le segment est dedans (la case de la grid)
density[2, i] = density[2, i] + 1
i += 1
# repasser tous les segment et ajouter leur propre densité max,min,mean pour chacun
max_seg_density = dict()
min_seg_density = dict()
mean_seg_density = dict()
seg_present_in = dict()
for segment in all_segments:
# FIXME convention --> le nom du segment c'est le timestamp de début de la course 1 (devrait ^etre unique)
seg_name = segment.times1[0]
min_seg_density[seg_name] = 100
max_seg_density[seg_name] = 0
mean_seg_density[seg_name] = 0
seg_present_in[seg_name] = 0
i = 0
for x in lat:
for y in long:
# parcours de la "grid" et regarder combien de point il y a pour chaque segment
for segment in all_segments:
seg_name = segment.times1[0]
seg = segment.positions
x_less = np.where(seg[0, :] >= (x - delta / 2))
x_more = np.where(seg[0, :] < (x + delta / 2))
count_x = np.intersect1d(x_less, x_more)
y_less = np.where(seg[1, :] >= (y - delta / 2))
y_more = np.where(seg[1, :] < (y + delta / 2))
count_y = np.intersect1d(y_less, y_more)
valid_coordinate = np.intersect1d(count_x, count_y).shape[0]
if valid_coordinate > 0:
if density[2, i] > max_seg_density[seg_name]:
# si le segment est dedans (la case de la grid)
max_seg_density[seg_name] = density[2, i]
if density[2, i] < min_seg_density[seg_name]:
min_seg_density[seg_name] = density[2, i]
mean_seg_density[seg_name] += density[2, i]
seg_present_in[seg_name] += 1
i += 1
for segment in all_segments:
seg_name = segment.times1[0]
mean_seg_density[seg_name] = mean_seg_density[seg_name] / seg_present_in[seg_name]
# print(max_seg_density)
# print(min_seg_density)
# print(seg_present_in)
# print(mean_seg_density)
# Print denstiy seg map
if GOOGLE_MAP_API_KEY is None:
gmap3 = GoogleMapPlotter(46.98, 6.89, 14)
else:
gmap3 = GoogleMapPlotter(46.98, 6.89, 14, apikey=GOOGLE_MAP_API_KEY)
self.races[referential_race_name].draw(color='cornflowerblue', gmap3=gmap3)
# Plot segment
for segment in all_segments:
segment.draw(color='purple', gmap3=gmap3)
# Plot density grid
for i in range(density.shape[1]):
if density[2, i] > 2:
gmap3.scatter([density[0, i]], [density[1, i]], "yellow", size=density[2, i], marker=False)
filename = os.path.join(st.files["output_folder"], f"seg_density_{referential_race_name}.html")
gmap3.draw(filename)
self.race_segment_density[referential_race_name] = density
self.race_density_delta[referential_race_name] = delta
self.race_mean_seg_density[referential_race_name] = mean_seg_density
def service_cb(self, request):
dt = (rospy.Time.now() - self.last_called_stamp).to_sec()
if dt < self.MIN_TIME_BETWEEN_CALLS:
raise rospy.ServiceException(
"Minimum time between plot requests is %f seconds. It's only been %f seconds"
% (self.MIN_TIME_BETWEEN_CALLS, dt))
if len(request.points) == 0:
raise rospy.ServiceException('No points present in request')
# Sort points into sequential groups of like types
plot_groups = []
for p in request.points:
added_to_group = False
# See if next point belongs in an existing group
for group in plot_groups:
added_to_group = group.add_to_group(p)
# Create new plotting group if current point hasn't been added
# to an existing one
if not added_to_group:
plot_groups.append(PlotGroup(p))
# Initialize Google Maps plot
map_type = 'satellite' if request.satellite_view else None
gplot = GoogleMapPlotter(request.center_lat,
request.center_lon,
request.zoom,
map_type=map_type)
# Loop through plotting groups to add plots to map
for group in plot_groups:
lats = [p.lat for p in group.members]
lons = [p.lon for p in group.members]
colors = [p.color for p in group.members]
texts = [p.text for p in group.members]
if group.type == PlotPoint.SCATTER_POINT:
gplot.scatter(lats,
lons,
group.color,
size=group.size,
marker=False)
elif group.type == PlotPoint.LINE:
gplot.plot(lats, lons, group.color, edge_width=group.size)
elif group.type == PlotPoint.MARKER:
gplot.scatter(lats, lons, group.color, marker=True)
elif group.type == PlotPoint.TEXT_LABEL or group.type == PlotPoint.MARKER_WITH_TEXT:
for i in xrange(len(group.members)):
gplot.text(
lats[i],
lons[i],
colors[i],
text=texts[i],
marker=(group.type == PlotPoint.MARKER_WITH_TEXT))
else:
raise rospy.ServiceException(
'Tried to plot an unsupported type')
self.last_called_stamp = rospy.Time.now()
if request.save_map:
# Just write map to designated file and be done
gplot.draw(request.filename, self.api_key)
rospy.loginfo('Saving map to: %s' % request.filename)
else:
# Write the map to the temporary file and immediately open default
# browser to view it
gplot.draw(self.tmp.name, self.api_key)
os.system('xdg-open ' + self.tmp.name)
return PlotMapResponse()
# import gmplot
from gmplot import GoogleMapPlotter
mymap = GoogleMapPlotter(37.428, -122.145, 16)
# mymap.marker(37.427, -122.145, "yellow")
# mymap.marker(37.428, -122.146, "cornflowerblue")
path = [(37.429, 37.428, 37.427, 37.427, 37.427),
(-122.145, -122.145, -122.145, -122.146, -122.146)]
path2 = [[i+.01 for i in path[0]], [i+.02 for i in path[1]]]
path3 = [(37.433302 , 37.431257 , 37.427644 , 37.430303), (-122.14488, -122.133121, -122.137799, -122.148743)]
path4 = [(37.423074, 37.422700, 37.422410, 37.422188, 37.422274, 37.422495, 37.422962, 37.423552, 37.424387, 37.425920, 37.425937),
(-122.150288, -122.149794, -122.148936, -122.148142, -122.146747, -122.14561, -122.144773, -122.143936, -122.142992, -122.147863, -122.145953)]
# mymap.plot(path[0], path[1], "plum", edge_width=10)
# mymap.plot(path2[0], path2[1], "red")
# mymap.polygon(path3[0], path3[1], edge_color="cyan", edge_width=5, face_color="blue", face_alpha=0.1)
# mymap.heatmap(path4[0], path4[1], threshold=10, radius=40)
# mymap.heatmap(path3[0], path3[1], threshold=10, radius=40, dissipating=False, gradient=[(30,30,30,0), (30,30,30,1), (50, 50, 50, 1)])
# mymap.scatter(path4[0], path4[1], c='r', marker=True)
# mymap.scatter(path4[0], path4[1], s=90, marker=False, alpha=0.1)
edge = [(37.429, 37.428),(-122.145, -122.145)]
mymap.plot(edge[0], edge[1], "plum", edge_width=20)
mymap.draw("mymap.html")
