def draw(self, proj, mouse_x, mouse_y, ui_manager):
# Prepare edges for next frame.
self.edge_src = np.empty((2, len(self.edgelists[self.count])), dtype=float)
self.edge_dst = np.empty((2, len(self.edgelists[self.count])), dtype=float)
for idx, edge in enumerate(self.edgelists[self.count]):
self.edge_src[:, idx] = self.network.nodes[edge[0]]['latlon']
self.edge_dst[:, idx] = self.network.nodes[edge[1]]['latlon']
self.edge_src_trans_x, self.edge_src_trans_y = proj.lonlat_to_screen(self.edge_src[1, :], self.edge_src[0, :])
self.edge_dst_trans_x, self.edge_dst_trans_y = proj.lonlat_to_screen(self.edge_dst[1, :], self.edge_dst[0, :])
# Initialize painter, plot nodes and addresses.
self.painter = BatchPainter()
self.painter.points(self.x, self.y, point_size=10, rounded=True)
if self.show_addresses:
self.painter.labels(self.x, self.y, self.node_addresses, font_size=10, anchor_x='left')
# Plot edges.
self.painter.set_color([255, 0, 0])
self.painter.lines(self.edge_src_trans_x, self.edge_src_trans_y, self.edge_dst_trans_x, self.edge_dst_trans_y, width=self.line_width)
# Draw and increment counter.
self.painter.batch_draw()
if self.count < len(self.edgelists) - 1:
self.count += 1
self.count = self.count % self.num_frames
print("count: {0}/{1}".format(self.count, self.num_frames))
# If saving frames.
if self.save_frames:
GeoplotlibApp.screenshot(f'./results/animation_frames/{self.count}.png')
def invalidate(self, proj):
try:
from scipy.spatial.qhull import Voronoi
except ImportError:
print('VoronoiLayer needs scipy >= 0.12')
raise
x, y = proj.lonlat_to_screen(self.data['lon'], self.data['lat'])
points = zip(x,y)
vor = Voronoi(points)
regions, vertices = VoronoiLayer.__voronoi_finite_polygons_2d(vor)
self.hotspots = HotspotManager()
self.painter = BatchPainter()
for idx, region in enumerate(regions):
polygon = vertices[region]
if self.line_color:
self.painter.set_color(self.line_color)
self.painter.linestrip(polygon[:,0], polygon[:,1], width=self.line_width, closed=True)
if self.cmap:
area = VoronoiLayer._get_area(polygon.tolist())
area = max(area, 1)
self.painter.set_color(self.cmap.to_color(area, self.max_area, 'log'))
self.painter.poly(polygon[:,0], polygon[:,1])
if self.f_tooltip:
record = {k: self.data[k][idx] for k in self.data.keys()}
self.hotspots.add_poly(polygon[:,0], polygon[:,1], self.f_tooltip(record))
def invalidate(self, proj):
self.painter = BatchPainter()
x0, y0 = proj.lonlat_to_screen(self.data[self.src_lon], self.data[self.src_lat])
x1, y1 = proj.lonlat_to_screen(self.data[self.dest_lon], self.data[self.dest_lat])
if type(self.color) == list:
self.painter.set_color(self.color)
self.painter.lines(x0, y0, x1, y1, width=self.linewidth)
else:
if self.color_by == 'distance':
manhattan = np.abs(x0-x1) + np.abs(y0-y1)
vmax = manhattan.max()
segmentations = np.logspace(0, log10(vmax), 20)
self.seg_scale = 'log'
else:
manhattan = self.data[self.color_by]
vmax = manhattan.max()
if self.seg_scale == 'log':
# value 20 maybe should be optional
segmentations = np.logspace(0, log10(vmax), 20)
else:
# linear
segmentations = np.linspace(0, vmax ,20)
for i in range(len(segmentations)-1, 1, -1):
mask = (manhattan > segmentations[i-1]) & (manhattan <= segmentations[i])
self.painter.set_color(self.cmap.to_color(segmentations[i], vmax, self.seg_scale))
self.painter.lines(x0[mask], y0[mask], x1[mask], y1[mask], width=self.linewidth)
def invalidate(self, proj):
self.painter = BatchPainter()
x, y = proj.lonlat_to_screen(self.data['lon'], self.data['lat'])
self.data['_xbin'] = (x / self.binsize).astype(int)
self.data['_ybin'] = (y / self.binsize).astype(int)
uniquevalues = set([
tuple(row)
for row in np.vstack([self.data['_xbin'], self.data['_ybin']]).T
])
results = {(v1,v2): self.f_group(self.data.where((self.data['_xbin'] == v1) & (self.data['_ybin'] == v2))) \
for v1, v2 in uniquevalues}
del self.data['_xbin']
del self.data['_ybin']
self.hotspot = HotspotManager()
if self.scalemax:
self.vmax = self.scalemax
else:
self.vmax = max(results.values()) if len(results) > 0 else 0
if self.vmax >= 1:
for (ix, iy), value in list(results.items()):
if value > self.scalemin:
self.painter.set_color(
self.cmap.to_color(value, self.vmax, self.colorscale))
l = self.binsize
rx = ix * self.binsize
ry = iy * self.binsize
self.painter.rect(rx, ry, rx + l, ry + l)
if self.show_tooltip:
self.hotspot.add_rect(rx, ry, l, l,
'Value: %d' % value)
def invalidate(self, proj):
self.painter = BatchPainter()
x, y = proj.lonlat_to_screen(self.data['lon'], self.data['lat'])
w = x.max() - x.min()
h = y.max() - y.min()
w = np.ceil(w / 2) * 2
h = np.ceil(h / 2) * 2
l = max(w, h)
root = QuadTree(x.min(), x.min() + l, y.min() + l, y.min())
maxarea = (root.right - root.left) * (root.top - root.bottom)
queue = [root]
done = []
while len(queue) > 0:
qt = queue.pop()
if qt.can_split(x, y):
queue.extend(qt.split())
else:
done.append(qt)
print((len(queue), len(done)))
if self.cmap is not None:
for qt in done:
area = (qt.right - qt.left) * (qt.top - qt.bottom)
self.painter.set_color(
self.cmap.to_color(1 + area, 1 + maxarea, 'log'))
self.painter.rect(qt.left, qt.top, qt.right, qt.bottom)
else:
for qt in done:
self.painter.linestrip([qt.left, qt.right, qt.right, qt.left],
[qt.top, qt.top, qt.bottom, qt.bottom],
closed=True)
def invalidate(self, proj):
"""
This method is called each time layers need to be redrawn, i.e. on zoom.
Typically in this method a BatchPainter is instantiated and all the rendering is performed
:param proj: the current Projector object
"""
self.painter = BatchPainter()
self.painter.set_color(self.color)
x1, y1 = proj.lonlat_to_screen(self.data['lon'], self.data['lat'])
self.painter.points(x1, y1, 2 * self.point_size, False)
for i in self.indexlst:
if i < len(self.data['lon']) - 1:
x1 = self.data['lon'][i]
y1 = self.data['lat'][i]
x2 = self.data['lon'][i+1]
y2 = self.data['lat'][i+1]
x1, y1 = proj.lonlat_to_screen(x1, y1)
x2, y2 = proj.lonlat_to_screen(x2, y2)
self.painter.lines(x1, y1, x2, y2, width=self.linewidth)
if self.f_tooltip:
for i in range(0, len(x1)):
record = {k: self.data[k][i] for k in self.data.keys()}
self.hotspots.add_rect(x1[i] - self.point_size, y1[i] - self.point_size,
2 * self.point_size, 2 * self.point_size,
self.f_tooltip(record))
def invalidate(self, proj):
self.painter = BatchPainter()
x, y = proj.lonlat_to_screen(self.data['lon'], self.data['lat'])
self.painter.set_color(self.color)
self.painter.labels(x, y, self.data[self.label_column],
font_name=self.font_name,
font_size=self.font_size,
anchor_x=self.anchor_x,
anchor_y=self.anchor_y)
def invalidate(self, proj):
self.painter = BatchPainter()
self.hotspots = HotspotManager()
self.painter.set_color(self.color)
if self.worker:
self.worker.stop()
self.worker.join()
self.queue = Queue.Queue()
self.worker = ShapeLoadingThread(self.queue, self.reader, self.shape_type, proj)
self.worker.start()
def invalidate(self, proj):
self.painter = BatchPainter()
x, y = proj.lonlat_to_screen(self.data['lon'], self.data['lat'])
if self.f_tooltip:
for i in range(0, len(x)):
record = {k: self.data[k][i] for k in self.data.keys()}
self.hotspots.add_rect(x[i] - self.point_size, y[i] - self.point_size,
2*self.point_size, 2*self.point_size,
self.f_tooltip(record))
self.painter.set_color(self.color)
self.painter.points(x, y, 2*self.point_size, False)
def invalidate(self, proj):
self.painter = BatchPainter()
self.painter.set_color(self.col)
x, y = proj.lonlat_to_screen(self.data['lon'], self.data['lat'])
if len(x) >= 3:
self.painter.convexhull(x, y, self.fill)
else:
self.painter.linestrip(x, y)
if self.point_size > 0:
self.painter.points(x, y, self.point_size)
def invalidate(self, proj):
self.painter = BatchPainter()
self.hotspots = HotspotManager()
for feature in self.data['features']:
if isfunction(self.color):
self.painter.set_color(self.color(feature['properties']))
else:
self.painter.set_color(self.color)
if feature['geometry']['type'] == 'Polygon':
for poly in feature['geometry']['coordinates']:
poly = np.array(poly)
x, y = proj.lonlat_to_screen(poly[:, 0], poly[:, 1])
if self.fill:
self.painter.poly(x, y)
else:
self.painter.linestrip(x,
y,
self.linewidth,
closed=True)
if self.f_tooltip:
self.hotspots.add_poly(
x, y, self.f_tooltip(feature['properties']))
elif feature['geometry']['type'] == 'MultiPolygon':
for multipoly in feature['geometry']['coordinates']:
for poly in multipoly:
poly = np.array(poly)
x, y = proj.lonlat_to_screen(poly[:, 0], poly[:, 1])
if self.fill:
self.painter.poly(x, y)
else:
self.painter.linestrip(x,
y,
self.linewidth,
closed=True)
if self.f_tooltip:
self.hotspots.add_poly(
x, y, self.f_tooltip(feature['properties']))
elif feature['geometry']['type'] == 'Point':
lon, lat = feature['geometry']['coordinates']
x, y = proj.lonlat_to_screen(np.array([lon]), np.array([lat]))
self.painter.points(x, y)
elif feature['geometry']['type'] == 'LineString':
line = np.array(feature['geometry']['coordinates'])
x, y = proj.lonlat_to_screen(line[:, 0], line[:, 1])
self.painter.linestrip(x, y, self.linewidth, closed=False)
else:
print(('unknow geometry %s' % feature['geometry']['type']))
def draw(self, proj, mouse_x, mouse_y, ui_manager):
self.painter = BatchPainter()
self.painter.set_color([0,0,255])
df = self.data.where((self.data['timestamp'] > self.t) & (self.data['timestamp'] <= self.t + 30*60))
proj.fit(BoundingBox.from_points(lons=df['lon'], lats=df['lat']), max_zoom=14)
x, y = proj.lonlat_to_screen(df['lon'], df['lat'])
self.painter.linestrip(x, y, 10)
self.t += 30
if self.t > self.data['timestamp'].max():
self.t = self.data['timestamp'].min()
self.painter.batch_draw()
ui_manager.info(epoch_to_str(self.t))
def invalidate(self, proj):
self.painter = BatchPainter()
x, y = proj.lonlat_to_screen(self.data['lon'], self.data['lat'])
k_means = KMeans(n_clusters=self.k)
k_means.fit(np.vstack([x, y]).T)
labels = k_means.labels_
self.cmap = create_set_cmap(set(labels), 'hsv')
for l in set(labels):
self.painter.set_color(self.cmap[l])
self.painter.convexhull(x[labels == l], y[labels == l])
self.painter.points(x[labels == l], y[labels == l], 2)
def invalidate(self, proj):
self.painter = BatchPainter()
xv, yv = proj.lonlat_to_screen(self.lon_edges, self.lat_edges)
rects = []
cols = []
for ix in range(len(xv)-1):
for iy in range(len(yv)-1):
d = self.values[iy, ix]
if d > self.vmin:
rects.append((xv[ix], yv[iy], xv[ix+1], yv[iy+1]))
cols.append(self.cmap.to_color(d, self.vmax, self.colormap_scale))
self.painter.batch_rects(rects, cols)
def invalidate(self, proj):
self.painter = BatchPainter()
x, y = proj.lonlat_to_screen(self.data['lon'], self.data['lat'])
if self.f_tooltip:
for i in range(0, len(x)):
record = {k: self.data[k][i] for k in list(self.data.keys())}
self.hotspots.add_rect(x[i] - self.marker_preferred_size / 2,
y[i] - self.marker_preferred_size / 2,
self.marker_preferred_size,
self.marker_preferred_size,
self.f_tooltip(record))
self.painter.sprites(self.marker, x, y, self.scale)
def invalidate(self, proj):
try:
from scipy.spatial.qhull import Delaunay
except ImportError:
print('DelaunayLayer needs scipy >= 0.12')
raise
self.painter = BatchPainter()
x, y = proj.lonlat_to_screen(self.data['lon'], self.data['lat'])
points = list(set(zip(x, y)))
dela = Delaunay(points)
edges = set()
for tria in dela.vertices:
edges.add((tria[0], tria[1]))
edges.add((tria[1], tria[2]))
edges.add((tria[2], tria[0]))
allx0 = []
ally0 = []
allx1 = []
ally1 = []
colors = []
for a, b in edges:
x0, y0 = dela.points[a]
x1, y1 = dela.points[b]
allx0.append(x0)
ally0.append(y0)
allx1.append(x1)
ally1.append(y1)
if self.line_color:
colors.append(self.line_color)
colors.append(self.line_color)
elif self.cmap:
l = math.sqrt((x0 - x1)**2 + (y0 - y1)**2)
c = self.cmap.to_color(l, self.max_lenght, 'log')
colors.append(c)
colors.append(c)
self.painter.lines(allx0,
ally0,
allx1,
ally1,
colors,
width=self.line_width)
def draw(self, proj, mouse_x, mouse_y, ui_manager):
self.painter = BatchPainter()
df = self.data.where((self.data['timestamp'] > self.t)
& (self.data['timestamp'] <= self.t + 15 * 60))
for taxi_id in set(df['taxi_id']):
grp = df.where(df['taxi_id'] == taxi_id)
self.painter.set_color(self.cmap[taxi_id])
x, y = proj.lonlat_to_screen(grp['lon'], grp['lat'])
self.painter.points(x, y, 10)
self.t += 2 * 60
if self.t > self.data['timestamp'].max():
self.t = self.data['timestamp'].min()
self.painter.batch_draw()
ui_manager.info(epoch_to_str(self.t))
def draw(self, proj, mouse_x, mouse_y, ui_manager):
self.painter = BatchPainter()
df = self.data.where((self.data['timestamp'] > self.t) & (self.data['timestamp'] <= self.t + 24*3600)) #set minimum time interval
for name in set(df['name']):
grp = df.where(df['name'] == name)
self.painter.set_color('blue') #set color, default: self.cmap[name]
x0, y0 = proj.lonlat_to_screen(grp['Slon'], grp['Slat'])
x1, y1 = proj.lonlat_to_screen(grp['Flon'], grp['Flat'])
self.painter.points(x0, y0, 3)
self.painter.lines(x0,y0,x1,y1,width=3)
self.t += 24*3600 #set animation step size
if self.t > self.data['timestamp'].max():
self.t = self.data['timestamp'].min()
self.painter.batch_draw()
ui_manager.info(epoch_to_str(self.t))
def draw(self, proj, mouse_x, mouse_y, ui_manager):
self.painter = BatchPainter()
x, y = proj.lonlat_to_screen(self.data['lon'], self.data['lat'])
if self.f_tooltip:
for i in range(0, len(x)):
record = {k: self.data[k][i] for k in self.data.keys()}
self.hotspots.add_rect(x[i] - self.point_size, y[i] - self.point_size,
2*self.point_size, 2*self.point_size,
self.f_tooltip(record))
self.color= "blue" #random.choice(foo)
self.painter.set_color(self.color)
self.painter.points(x[self.frame_counter], y[self.frame_counter], 2*self.point_size, False)
self.painter.batch_draw()
picked = self.hotspots.pick(mouse_x, mouse_y)
if picked:
ui_manager.tooltip(picked)
self.frame_counter += 1
time.sleep(0.4)
if self.frame_counter == len(x):
self.frame_counter = 0
def invalidate(self, proj):
self.painter = BatchPainter()
x0, y0 = proj.lonlat_to_screen(self.data[self.src_lon],
self.data[self.src_lat])
x1, y1 = proj.lonlat_to_screen(self.data[self.dest_lon],
self.data[self.dest_lat])
manhattan = np.abs(x0 - x1) + np.abs(y0 - y1)
vmax = manhattan.max()
distances = np.logspace(0, log10(manhattan.max()), 20)
for i in range(len(distances) - 1, 1, -1):
mask = (manhattan > distances[i - 1]) & (manhattan <= distances[i])
if type(self.color) == list:
self.painter.set_color(self.color)
else:
self.painter.set_color(
self.cmap.to_color(distances[i], vmax, 'log'))
self.painter.lines(x0[mask],
y0[mask],
x1[mask],
y1[mask],
width=self.linewidth)
def invalidate(self, proj):
self.painter = BatchPainter()
xv, yv = proj.lonlat_to_screen(self.values['lon'], self.values['lat'])
rects_vertices = []
rects_colors = []
if self.method == 'kde':
try:
import statsmodels.api as sm
except:
raise Exception('KDE requires statsmodel')
kde_res = sm.nonparametric.KDEMultivariate(data=[xv, yv],
var_type='cc',
bw=self.bw)
xgrid, ygrid = self._get_grid(proj)
xmesh, ymesh = np.meshgrid(xgrid, ygrid)
grid_coords = np.append(xmesh.reshape(-1, 1),
ymesh.reshape(-1, 1),
axis=1)
z = kde_res.pdf(grid_coords.T)
z = z.reshape(len(ygrid), len(xgrid))
# np.save('z.npy', z)
# z = np.load('z.npy')
print(('smallest non-zero density:', z[z > 0][0]))
print(('max density:', z.max()))
if self.cut_below is None:
zmin = z[z > 0][0]
else:
zmin = self.cut_below
if self.clip_above is None:
zmax = z.max()
else:
zmax = self.clip_above
for ix in range(len(xgrid) - 1):
for iy in range(len(ygrid) - 1):
if z[iy, ix] > zmin:
rects_vertices.append((xgrid[ix], ygrid[iy],
xgrid[ix + 1], ygrid[iy + 1]))
rects_colors.append(
self.cmap.to_color(z[iy, ix], zmax, self.scaling))
elif self.method == 'hist':
try:
from scipy.ndimage import gaussian_filter
except:
raise Exception('KDE requires scipy')
xgrid, ygrid = self._get_grid(proj)
H, _, _ = np.histogram2d(yv, xv, bins=(ygrid, xgrid))
if H.sum() == 0:
print('no data in current view')
return
H = gaussian_filter(H, sigma=self.bw)
print(('smallest non-zero count', H[H > 0][0]))
print(('max count:', H.max()))
if self.cut_below is None:
Hmin = H[H > 0][0]
else:
Hmin = self.cut_below
if self.clip_above is None:
self.Hmax = H.max()
else:
self.Hmax = self.clip_above
if self.scaling == 'ranking':
from statsmodels.distributions.empirical_distribution import ECDF
ecdf = ECDF(H.flatten())
for ix in range(len(xgrid) - 2):
for iy in range(len(ygrid) - 2):
if H[iy, ix] > Hmin:
rects_vertices.append((xgrid[ix], ygrid[iy],
xgrid[ix + 1], ygrid[iy + 1]))
if self.scaling == 'ranking':
rects_colors.append(
self.cmap.to_color(
ecdf(H[iy, ix]) - ecdf(Hmin),
1 - ecdf(Hmin), 'lin'))
else:
rects_colors.append(
self.cmap.to_color(H[iy, ix], self.Hmax,
self.scaling))
else:
raise Exception('method not supported')
self.painter.batch_rects(rects_vertices, rects_colors)
def draw(self, proj, mouse_x, mouse_y, ui_manager):
self.painter = BatchPainter()
self.painter.points(self.x[self.frame_counter],
self.y[self.frame_counter])
self.painter.batch_draw()
self.frame_counter += 1
def invalidate(self, proj):
x, y = proj.lonlat_to_screen(self.data['lon'], self.data['lat'])
self.painter = BatchPainter()
self.painter.set_color(self.color)
self.painter.points(x, y, point_size=self.point_size, rounded=True)
def __init__(self):
self.data = read_csv('data/taxi.csv')
self.data = self.data.where(self.data['taxi_id'] == list(set(self.data['taxi_id']))[2])
self.t = self.data['timestamp'].min()
self.painter = BatchPainter()
def __init__(self):
self.data = read_csv('data/taxi.csv')
self.cmap = colorbrewer(self.data['taxi_id'], alpha=220)
self.t = self.data['timestamp'].min()
self.painter = BatchPainter()
def __init__(self):
self.data = read_csv('SLOCs.csv')
self.cmap = colorbrewer(self.data['name'], alpha=220)
self.t = self.data['timestamp'].min()
self.painter = BatchPainter()
