def create_map():
shp = fiona.open("./Kaupunginosajako/KaupunginosajakoPolygon_WGS84.shp"
) # helsinki districts shapefile
coords = shp.bounds # Extract the bound coordinates from the shapefile
shp.close()
fig, ax = plt.subplots(figsize=(8, 8)) # figure and axis objects
m = Basemap(
projection='tmerc',
ellps='WGS84', # set transverse mercator proj. and ellipsoid
lon_0=(coords[0] + coords[2]) / 2, # longitude center
lat_0=(coords[1] + coords[3]) / 2, # latitude center
llcrnrlon=coords[0], # left lower corner
llcrnrlat=coords[1],
urcrnrlon=coords[2], # upper right corner
urcrnrlat=coords[3],
resolution='c',
suppress_ticks=True)
m.readshapefile("./Kaupunginosajako/KaupunginosajakoPolygon_WGS84",
name='helsinki',
drawbounds=True,
color='blue')
df_map = pd.DataFrame({
"poly": [Polygon(xy) for xy in m.helsinki],
"district": [x["nimi_fi"] for x in m.helsinki_info]
})
df_map["area_km"] = df_map["poly"].map(lambda x: x.area / 1000)
map_points = [
Point(m(x, y)) for x, y in zip(stations.longitude, stations.latitude)
] # Convert Data Points to projection, then to Shapely
all_points = MultiPoint(map_points)
district_poly = prep(MultiPolygon(list(df_map.poly.values)))
all_points = list(
filter(district_poly.contains,
all_points)) # Select only points within map boundaries
df_map["bikes_count"] = df_map.poly.apply(points_per_poly,
args=(all_points, ))
df_map["bikes_per_area"] = df_map.bikes_count / df_map.area_km
df_map.patch = df_map.poly.map(lambda x: PolygonPatch(x))
pc = PatchCollection(df_map.patch, match_original=False, zorder=2)
pc.set(array=df_map.bikes_per_area.values,
cmap='Reds') # impose color map onto patch collection
fig.colorbar(pc,
label="Bike density") # Draw Colorbar and display the measure
ax.add_collection(pc) # add patchcollection to axis
centroids = df_map["poly"].map(
lambda x: x.centroid) # get center of each polygon
for i, (point, label) in enumerate(zip(centroids, df_map.district)):
if df_map.loc[i,
"bikes_per_area"] > df_map.bikes_per_area.quantile(0.05):
ax.text(point.x, point.y, label, ha='center',
size=8) # plot text in center
plt.show()
def plot_field(mesh,
element_values,
labels=None,
title=None,
vmin=None,
vmax=None,
save=None):
'''
Creates a plot of a scalar field over the mesh as a color plot. The values of
each element is constantly given by element_vaues.
mesh - a mesh numpy array, each row is an element with 3 nodes ([x1, y1, x2, y2, x3, y3])
element_values - The values to be plotted, one for each element (numpy array)
'''
fig, ax = plt.subplots(figsize=(10, 8))
ev = element_values * (10**4)
patches = []
for i, elm in enumerate(mesh):
if len(elm) == 6:
ax.plot([elm[0], elm[2]], [elm[1], elm[3]], 'ro-')
ax.plot([elm[0], elm[4]], [elm[1], elm[5]], 'ro-')
ax.plot([elm[2], elm[4]], [elm[3], elm[5]], 'ro-')
xy = np.array([elm[0:2], elm[2:4], elm[4:6]])
if len(elm) == 8:
ax.plot([elm[0], elm[2]], [elm[1], elm[3]], 'ro-')
ax.plot([elm[2], elm[4]], [elm[3], elm[5]], 'ro-')
ax.plot([elm[4], elm[6]], [elm[5], elm[7]], 'ro-')
ax.plot([elm[6], elm[0]], [elm[7], elm[1]], 'ro-')
xy = np.array([elm[0:2], elm[2:4], elm[4:6], elm[6:8]])
polygon = Polygon(xy, True)
patches.append(polygon)
ax.text(np.mean(elm[0::2]), np.mean(elm[1::2]), str(i), size=17)
if labels is not None:
x = (elm[0] + elm[2] + elm[4]) / 3.
y = (elm[1] + elm[3] + elm[5]) / 3.
plt.text(x, y, str(i), size=17)
p = PatchCollection(patches, alpha=1.0)
if vmin is not None: ev[ev < vmin] = vmin
if vmax is not None: ev[ev > vmax] = vmax
p.set(array=ev, cmap='jet')
ax.add_collection(p)
cbar = fig.colorbar(p, ax=ax)
cbar.ax.set_title(r'$10^{-4}$', size=27)
cbar.ax.tick_params(labelsize=17)
ax.tick_params(labelsize=17)
l = 0.3 * np.abs(np.max(mesh))
ax.text(l * 1.03, l / 10., "x", size=27)
ax.quiver(0, 0, l, 0, angles='xy', scale_units='xy', scale=1)
ax.text(-l / 5., 1.05 * l, "y", size=27)
ax.quiver(0, 0, 0, l, angles='xy', scale_units='xy', scale=1)
ax.axis('equal')
if title is not None:
ax.set_title(title, size=37)
if save is not None: plt.savefig(save)
def plot_generated_nodes(partitioner):
import matplotlib.cm as cm
import matplotlib.pyplot as plt
from matplotlib.collections import PatchCollection
from matplotlib.patches import Rectangle
from numpy import array as np_array
areas = list()
fig = plt.figure()
fig.set_size_inches(15, 20)
ax1 = fig.add_subplot(211)
xs = [(s.llx, s.urx) for s in partitioner.sinks + [partitioner.source]]
ys = [(s.lly, s.ury) for s in partitioner.sinks + [partitioner.source]]
x_max, y_max = max([x[1] for x in xs]), max([y[1] for y in ys])
x_min, y_min = min([x[0] for x in xs]), min([y[0] for y in ys])
for s in partitioner.sinks:
x, y = s.llx, s.lly
w, h = s.width, s.height
rectangle = Rectangle((x, y), w, h, alpha=0.3)
ax1.add_patch(rectangle)
x, y = partitioner.source.llx, partitioner.source.lly
w, h = partitioner.source.width, partitioner.source.height
rectangle = Rectangle((x, y), w, h, facecolor='red', alpha=0.3)
ax1.add_patch(rectangle)
ax1.set_xlim([x_min, x_max])
ax1.set_ylim([x_min, y_max])
patches = list()
for n in partitioner.nodes:
x, y = n.llx, n.lly
w, h = n.width, n.height
rectangle = Rectangle((x, y), w, h)
patches.append(rectangle)
areas.append(n.area)
ax2 = fig.add_subplot(212)
col = PatchCollection(patches, alpha=0.4)
col.set(array=np_array(areas), cmap='jet')
ax2.add_collection(col)
ax2.set_xlim([x_min, x_max])
ax2.set_ylim([x_min, y_max])
# plt.colorbar(col)
fig.savefig('test.png', dpi=200)
def __plot_patches(self, array, ax, **kwargs):
"""
General patch plotter, workhorse of the class
Parameters
----------
array : array to plot
ax : matplotlib.pyplot.axes
kwargs : matplotlib keyword arguments
Returns
-------
matplotlib.pyplot.axes
"""
# if "color" not in kwargs:
# kwargs["facecolor"] = "None"
if 'vmin' in kwargs:
vmin = kwargs.pop('vmin')
else:
vmin = np.min(array)
if 'vmax' in kwargs:
vmax = kwargs.pop('vmax')
else:
vmax = np.max(array)
patches = [Polygon(hru, True) for hru in self.prms_dis.xypts]
p = PatchCollection(patches)
p.set_array(array)
p.set_clim(vmin=vmin, vmax=vmax)
p.set(**kwargs)
ax.add_collection(p)
extent = self.extent
ax.set_xlim([extent[0], extent[1]])
ax.set_ylim([extent[2], extent[3]])
return p
class SceneVisualizer:
"""Context for social nav vidualization"""
def __init__(self,
scene,
output=None,
limits=None,
writer="imagemagick",
cmap="viridis",
agent_colors=None,
**kwargs):
self.scene = scene
self.states, self.group_states = self.scene.get_states()
self.cmap = cmap
self.agent_colors = agent_colors
self.frames = self.scene.get_length()
self.output = output
self.writer = writer
self.limits = limits
self.fig, self.ax = plt.subplots(**kwargs)
self.ani = None
self.group_actors = None
self.group_collection = PatchCollection([])
self.group_collection.set(
animated=True,
alpha=0.2,
cmap=self.cmap,
facecolors="none",
edgecolors="purple",
linewidth=2,
clip_on=True,
)
self.human_actors = None
self.human_collection = PatchCollection([])
self.human_collection.set(animated=True,
alpha=0.6,
cmap=self.cmap,
clip_on=True)
def plot(self):
"""Main method for create plot"""
self.plot_obstacles()
self.plot_fires()
self.plot_exits()
groups = self.group_states[0] # static group for now
if not groups:
for ped in range(self.scene.peds.size()):
x = self.states[:, ped, 0]
y = self.states[:, ped, 1]
self.ax.plot(x, y, "-o", label=f"ped {ped}", markersize=2.5)
else:
colors = plt.cm.rainbow(np.linspace(0, 1, len(groups)))
for i, group in enumerate(groups):
for ped in group:
x = self.states[:, ped, 0]
y = self.states[:, ped, 1]
self.ax.plot(x,
y,
"-o",
label=f"ped {ped}",
markersize=2.5,
color=colors[i])
self.ax.legend()
return self.fig
def animate(self):
"""Main method to create animation"""
self.ani = mpl_animation.FuncAnimation(
self.fig,
init_func=self.animation_init,
func=self.animation_update,
frames=self.frames,
blit=True,
interval=200,
)
return self.ani
def __enter__(self):
logger.info("Start plotting.")
self.fig.set_tight_layout(True)
self.ax.grid(linestyle="dotted")
self.ax.set_aspect("equal")
self.ax.margins(2.0)
self.ax.set_axisbelow(True)
self.ax.set_xlabel("x [m]")
self.ax.set_ylabel("y [m]")
plt.rcParams["animation.html"] = "jshtml"
# x, y limit from states, only for animation
margin = 2.0
if self.limits is None:
xy_limits = np.array([minmax(state) for state in self.states
]) # (x_min, y_min, x_max, y_max)
xy_min = np.min(xy_limits[:, :2], axis=0) - margin
xy_max = np.max(xy_limits[:, 2:4], axis=0) + margin
self.ax.set(xlim=(xy_min[0], xy_max[0]),
ylim=(xy_min[1], xy_max[1]))
else:
limits = self.limits
self.ax.set(xlim=(limits[0] - margin, limits[1] + margin),
ylim=(limits[2] - margin, limits[3] + margin))
# # recompute the ax.dataLim
# self.ax.relim()
# # update ax.viewLim using the new dataLim
# self.ax.autoscale_view()
return self
def __exit__(self, exception_type, exception_value, traceback):
if exception_type:
logger.error(
f"Exception type: {exception_type}; Exception value: {exception_value}; Traceback: {traceback}"
)
logger.info("Plotting ends.")
if self.output:
if self.ani:
output = self.output + ".gif"
logger.info(f"Saving animation as {output}")
self.ani.save(output, writer=self.writer)
else:
output = self.output + ".png"
logger.info(f"Saving plot as {output}")
self.fig.savefig(output, dpi=300)
plt.close(self.fig)
def plot_human(self, step=-1):
"""Generate patches for human
:param step: index of state, default is the latest
:return: list of patches
"""
states, _ = self.scene.get_states()
current_state = states[step]
# radius = 0.2 + np.linalg.norm(current_state[:, 2:4], axis=-1) / 2.0 * 0.3
radius = [0.2] * current_state.shape[0]
if self.human_actors:
for i, human in enumerate(self.human_actors):
human.center = current_state[i, :2]
human.set_radius(0.2)
# human.set_radius(radius[i])
else:
self.human_actors = [
Circle(pos, radius=r)
for pos, r in zip(current_state[:, :2], radius)
]
self.human_collection.set_paths(self.human_actors)
if not self.agent_colors:
self.human_collection.set_array(np.arange(current_state.shape[0]))
else:
# set colors for each agent
assert len(self.human_actors) == len(
self.agent_colors
), "agent_colors must be the same length as the agents"
self.human_collection.set_facecolor(self.agent_colors)
def plot_groups(self, step=-1):
"""Generate patches for groups
:param step: index of state, default is the latest
:return: list of patches
"""
states, group_states = self.scene.get_states()
current_state = states[step]
current_groups = group_states[step]
if self.group_actors: # update patches, else create
points = [current_state[g, :2] for g in current_groups]
for i, p in enumerate(points):
self.group_actors[i].set_xy(p)
else:
self.group_actors = [
Polygon(current_state[g, :2]) for g in current_groups
]
self.group_collection.set_paths(self.group_actors)
def plot_obstacles(self):
for s in self.scene.get_obstacles():
self.ax.add_patch(
Rectangle((s[:, 0][0], s[:, 1][0]),
s[:, 0][-1] - s[:, 0][0],
s[:, 1][-1] - s[:, 1][0],
fill=True,
color="black"))
def plot_fires(self):
if self.scene.get_fires() is not None:
f = self.scene.get_fires()[0]
self.ax.add_patch(
Rectangle((f[:, 0][0], f[:, 1][0]),
f[:, 0][-1] - f[:, 0][0],
f[:, 1][-1] - f[:, 1][0],
fill=True,
color="red"))
if len(self.scene.get_fires()) > 1:
b = self.scene.get_fires()[1]
self.ax.add_patch(
Rectangle((b[:, 0][0], b[:, 1][0]),
b[:, 0][-1] - b[:, 0][0],
b[:, 1][-1] - b[:, 1][0],
fill=False,
color="red"))
def plot_exits(self):
if self.scene.get_exits() is not None:
for e in self.scene.get_exits():
# continue
# self.ax.add_patch(Circle((e[0],e[1]), 1, fill=True, color="green", alpha=0.1))
self.ax.add_patch(
Circle((e[0], e[1]),
e[2],
fill=True,
color="green",
alpha=0.1))
def plot_smoke(self, step=-1):
if self.scene.get_fires() is not None:
f = self.scene.get_fires()[0]
fcx = f[:, 0][0] + (f[:, 0][-1] - f[:, 0][0]) / 2
fcy = f[:, 1][0] + (f[:, 1][-1] - f[:, 1][0]) / 2
rad = self.scene.peds.get_smoke_radii()[step]
self.ax.add_patch(
Circle((fcx, fcy), rad, fill=True, color="black", alpha=0.005))
def animation_init(self):
self.plot_obstacles()
self.plot_fires()
self.plot_exits()
self.ax.add_collection(self.group_collection)
self.ax.add_collection(self.human_collection)
return (self.group_collection, self.human_collection)
def animation_update(self, i):
self.plot_groups(i)
self.plot_human(i)
self.plot_smoke(i)
return (self.group_collection, self.human_collection)
def plot_data(self):
fig, ax = plt.subplots()
escaped = [
i / self.scene.peds.get_nr_peds() * 100
for i in self.scene.peds.escaped
]
health = [i * 100 for i in self.scene.peds.av_health]
panic = [i * 100 for i in self.scene.peds.av_panic]
dead = [
i / self.scene.peds.get_nr_peds() * 100
for i in self.scene.peds.dead
]
timesteps = [t for t in range(len(escaped))]
ax.plot(timesteps, escaped, color="green", label="escaped")
ax.plot(timesteps, health, color="red", label="health")
ax.plot(timesteps, panic, color="purple", label="panic")
ax.plot(timesteps, dead, color="black", label="dead")
ax.set_xlabel("Timestep")
ax.set_ylabel("[%]")
ax.set_ylim([0, 100])
ax.set_title(
"Number of escaped and dead people and average health and panic.")
ax.legend()
ax.grid(linestyle="dotted")
fig.savefig(self.output + "_data.png")
logger.info("Created plot of data.")
for a in range(i):
for b in range(j):
ax = axes.axes_row[a][b]
ax.set_xticks([])
ax.set_yticks([])
ax.set_frame_on(False)
collection = PatchCollection([Polygon(face) for face in face_coords])
ax.add_collection(collection)
deviations, cmap = data_collection[a][b][to_plot]
collection.set(array=deviations, cmap=cmap)
ax.cax.colorbar(collection)
contours = data_collection[a][b]["contours"]
contours = PolyCollection(contours, closed=False, linewidth=1.0, facecolors='none', edgecolor="black")
ax.add_collection(contours)
mse_loss = data_collection[a][b]["mse_loss"]
xlabel = "loss: {}".format(round(mse_loss, 2))
ax.set_xlabel(xlabel)
ax.set_aspect("equal")
ax.autoscale(tight=True)
def plot_counties(
ax,
counties,
values=None,
edgecolors=None,
contourcolor="white",
hatch_surround=None,
xlim=None,
ylim=None,
background=True,
xticks=True,
yticks=True,
grid=True,
frame=True,
xlabel="Longitude [in dec. degrees]",
ylabel="Latitude [in dec. degrees]",
lw=1):
polygons = [r["shape"] for r in counties.values()]
# extend german borders :S and then shrink them again after unifying
# gets rid of many holes at the county boundaries
contour = cascaded_union([pol.buffer(0.01)
for pol in polygons]).buffer(-0.01)
xmin, ymin, xmax, ymax = contour.bounds
if xlim is None:
xlim = [xmin, xmax]
if ylim is None:
ylim = [ymin, ymax]
surround = PolygonPatch(Polygon([(xlim[0], ylim[0]), (xlim[0], ylim[1]), (
xlim[1], ylim[1]), (xlim[1], ylim[0])]).difference(contour))
contour = PolygonPatch(contour, lw=lw)
pc = PatchCollection([PolygonPatch(p, lw=lw)
for p in polygons], cmap=matplotlib.cm.magma, alpha=1.0)
if values is not None:
if isinstance(values, (dict, OrderedDict)):
values = np.array([values.setdefault(r, np.nan)
for r in counties.keys()])
elif isinstance(values, str):
values = np.array([r.setdefault(values, np.nan)
for r in counties.values()])
else:
assert np.size(values) == len(counties), "Number of values ({}) doesn't match number of counties ({})!".format(
np.size(values), len(counties))
pc.set_clim(0, 10)
nans = np.isnan(values)
values[nans] = 0
values = np.ma.MaskedArray(values, mask=nans)
pc.set(array=values, cmap='magma')
else:
pc.set_facecolors("none")
if edgecolors is not None:
if isinstance(edgecolors, (dict, OrderedDict)):
edgecolors = np.array([edgecolors.setdefault(r, "none")
for r in counties.keys()])
elif isinstance(edgecolors, str):
edgecolors = np.array([r.setdefault(edgecolors, "none")
for r in counties.values()])
pc.set_edgecolors(edgecolors)
else:
pc.set_edgecolors("none")
if hatch_surround is not None:
surround.set_hatch(hatch_surround)
surround.set_facecolor("none")
ax.add_patch(surround)
cb = plt.colorbar(pc, shrink=0.6)
cb.set_ticks([0,5,10])
#cb.set_yticks([0.00004])
ax.add_collection(pc)
if contourcolor is not None:
contour.set_edgecolor(contourcolor)
contour.set_facecolor("none")
ax.add_patch(contour)
if isinstance(background, bool):
ax.patch.set_visible(background)
else:
ax.patch.set_color(background)
ax.grid(grid)
ax.set_frame_on(frame)
ax.set_xlim(*xlim)
ax.set_ylim(*ylim)
ax.set_aspect(1.43)
if xlabel:
ax.set_xlabel(xlabel, fontsize=14)
if ylabel:
ax.set_ylabel(ylabel, fontsize=14)
ax.tick_params(axis="x", which="both", bottom=xticks, labelbottom=xticks)
ax.tick_params(axis="y", which="both", left=yticks, labelleft=yticks)
#plt.colorbar()
return pc, contour, surround
def process_corrmatrix(out_dir, corrmatrix):
# Pairwise Spearman correlations of log2 fold gene expression changes between each disorder and CTL in each brain region.
# Cite: https://stackoverflow.com/questions/59381273/heatmap-with-circles-indicating-size-of-population
N = 4
M = 4
ylabels = ["Parkinson", "Alzheimer"] * 2
xlabels = ["Alzheimer", "Parkinson"] * 2
biofluid_regions = ["Cerebrospinal", "Serum"]
# names for positions along x-axis 0..9
disorders_x = ["Alzheimer", "Parkinson"] * 2
biofluid_regions_x = ["Cerebrospinal", "Cerebrospinal", "Serum", "Serum"]
# names for positions along x-axis 0..9
disorders_y = ["Parkinson", "Alzheimer"] * 2
biofluid_regions_y = ["Serum", "Serum", "Cerebrospinal", "Cerebrospinal"]
# size of circles
s = np.zeros((N, M))
for y in range(N):
for x in range(M):
lrt1 = "data/out/" + biofluid_regions_x[x] + "/" + disorders_x[
x] + "/lrt.tsv"
lrt2 = "data/out/" + biofluid_regions_y[y] + "/" + disorders_y[
y] + "/lrt.tsv"
# Make sure ltr1 exists otherwise zero correlation
if not os.path.exists(lrt1):
s[y][x] = 0.5
continue
# Make sure ltr2 exists otherwise zero correlation
if not os.path.exists(lrt2):
s[y][x] = 0.5
continue
if lrt1 != lrt2:
df_x = pd.read_csv(lrt1, sep='\t', index_col=0)
df_y = pd.read_csv(lrt2, sep='\t', index_col=0)
corr = np.abs(df_x["log2FoldChange"].corr(
df_y["log2FoldChange"]))
s[y][x] = corr
else:
s[y][x] = 0.0 #Dont set diagnols
c = np.ones((N, M))
fig, ax = plt.subplots(figsize=(11, 8))
R = s / s.max() / 2
x, y = np.meshgrid(np.arange(M), np.arange(N))
circles = [
plt.Circle((j, i), radius=r)
for r, j, i in zip(R.flat, x.flat, y.flat)
]
col = PatchCollection(circles)
col.set(array=s.flatten(), cmap='coolwarm')
ax.add_collection(col)
ax.set(xticks=np.arange(M),
yticks=np.arange(N),
xticklabels=xlabels,
yticklabels=ylabels)
ax.set_xticks(np.arange(M + 1) - 0.5, minor=True)
ax.set_yticks(np.arange(N + 1) - 0.5, minor=True)
ax.grid(which='minor')
ax.text(0, -0.9, "Cerebrospinal", size=20, color='red')
ax.text(2, -0.9, "Serum", size=20, color='green')
ax.text(3.55, 2, "Cerebrospinal", size=20, rotation=90, color='red')
ax.text(3.55, 0, "Serum", size=20, rotation=90, color='green')
fig.colorbar(col)
plt.suptitle(corrmatrix["title"])
plt.savefig(out_dir + "/corrmatrix.png")
return
def plot_array(self, a, masked_values=None, **kwargs):
"""
Plot an array. If the array is three-dimensional, then the method
will plot the layer tied to this class (self.layer).
Parameters
----------
a : numpy.ndarray
Array to plot.
masked_values : iterable of floats, ints
Values to mask.
**kwargs : dictionary
keyword arguments passed to matplotlib.pyplot.patchcollection
Returns
-------
quadmesh : matplotlib.collections.QuadMesh
"""
if not isinstance(a, np.ndarray):
a = np.array(a)
if a.ndim == 2:
plotarray = a[self.layer, :]
elif a.ndim == 1:
plotarray = a
else:
raise Exception('Array must be of dimension 1, 2 or 3')
if masked_values is not None:
for mval in masked_values:
plotarray = np.ma.masked_equal(plotarray, mval)
if 'ax' in kwargs:
ax = kwargs.pop('ax')
else:
ax = self.ax
xgrid = np.array(self.mg.xvertices)
ygrid = np.array(self.mg.yvertices)
patches = [Polygon(list(zip(xgrid[i], ygrid[i])), closed=True)
for i in range(xgrid.shape[0])]
p = PatchCollection(patches)
p.set_array(plotarray)
if 'vmin' in kwargs:
vmin = kwargs.pop('vmin')
else:
vmin = None
if 'vmax' in kwargs:
vmax = kwargs.pop('vmax')
else:
vmax = None
p.set_clim(vmin=vmin, vmax=vmax)
# send rest of kwargs to quadmesh
p.set(**kwargs)
ax.add_collection(p)
ax.set_xlim(self.extent[0], self.extent[1])
ax.set_ylim(self.extent[2], self.extent[3])
return p
class SceneVisualizer:
"""Context for social nav vidualization"""
def __init__(self,
scene,
output=None,
writer="imagemagick",
cmap="viridis",
**kwargs):
self.scene = scene
self.states, self.group_states = self.scene.get_states()
self.cmap = cmap
self.frames = self.scene.get_length()
self.output = output
self.writer = writer
self.fig, self.ax = plt.subplots(**kwargs)
self.ani = None
self.group_actors = None
self.group_collection = PatchCollection([])
self.group_collection.set(
animated=True,
alpha=0.2,
cmap=self.cmap,
facecolors="none",
edgecolors="purple",
linewidth=2,
clip_on=True,
)
self.human_actors = None
self.human_collection = PatchCollection([])
self.human_collection.set(animated=True,
alpha=0.6,
cmap=self.cmap,
clip_on=True)
def plot(self):
"""Main method for create plot"""
self.plot_obstacles()
groups = self.group_states[0] # static group for now
if not groups:
for ped in range(self.scene.peds.size()):
x = self.states[:, ped, 0]
y = self.states[:, ped, 1]
self.ax.plot(x, y, "-o", label=f"ped {ped}", markersize=2.5)
else:
colors = plt.cm.rainbow(np.linspace(0, 1, len(groups)))
for i, group in enumerate(groups):
for ped in group:
x = self.states[:, ped, 0]
y = self.states[:, ped, 1]
self.ax.plot(x,
y,
"-o",
label=f"ped {ped}",
markersize=2.5,
color=colors[i])
self.ax.legend()
return self.fig
def animate(self):
"""Main method to create animation"""
self.ani = mpl_animation.FuncAnimation(
self.fig,
init_func=self.animation_init,
func=self.animation_update,
frames=self.frames,
blit=True,
)
return self.ani
def __enter__(self):
logger.info("Start plotting.")
self.fig.set_tight_layout(True)
self.ax.grid(linestyle="dotted")
self.ax.set_aspect("equal")
self.ax.margins(2.0)
self.ax.set_axisbelow(True)
self.ax.set_xlabel("x [m]")
self.ax.set_ylabel("y [m]")
plt.rcParams["animation.html"] = "jshtml"
# x, y limit from states, only for animation
margin = 2.0
xy_limits = np.array([minmax(state) for state in self.states
]) # (x_min, y_min, x_max, y_max)
xy_min = np.min(xy_limits[:, :2], axis=0) - margin
xy_max = np.max(xy_limits[:, 2:4], axis=0) + margin
self.ax.set(xlim=(xy_min[0], xy_max[0]), ylim=(xy_min[1], xy_max[1]))
# # recompute the ax.dataLim
# self.ax.relim()
# # update ax.viewLim using the new dataLim
# self.ax.autoscale_view()
return self
def __exit__(self, exception_type, exception_value, traceback):
if exception_type:
logger.error(
f"Exception type: {exception_type}; Exception value: {exception_value}; Traceback: {traceback}"
)
logger.info("Plotting ends.")
if self.output:
if self.ani:
output = self.output + ".gif"
logger.info(f"Saving animation as {output}")
self.ani.save(output, writer=self.writer)
else:
output = self.output + ".png"
logger.info(f"Saving plot as {output}")
self.fig.savefig(output, dpi=300)
plt.close(self.fig)
def plot_human(self, step=-1):
"""Generate patches for human
:param step: index of state, default is the latest
:return: list of patches
"""
states, _ = self.scene.get_states()
current_state = states[step]
# radius = 0.2 + np.linalg.norm(current_state[:, 2:4], axis=-1) / 2.0 * 0.3
radius = [0.2] * current_state.shape[0]
if self.human_actors:
for i, human in enumerate(self.human_actors):
human.center = current_state[i, :2]
human.set_radius(0.2)
# human.set_radius(radius[i])
else:
self.human_actors = [
Circle(pos, radius=r)
for pos, r in zip(current_state[:, :2], radius)
]
self.human_collection.set_paths(self.human_actors)
self.human_collection.set_array(np.arange(current_state.shape[0]))
def plot_groups(self, step=-1):
"""Generate patches for groups
:param step: index of state, default is the latest
:return: list of patches
"""
states, group_states = self.scene.get_states()
current_state = states[step]
current_groups = group_states[step]
if self.group_actors: # update patches, else create
points = [current_state[g, :2] for g in current_groups]
for i, p in enumerate(points):
self.group_actors[i].set_xy(p)
else:
self.group_actors = [
Polygon(current_state[g, :2]) for g in current_groups
]
self.group_collection.set_paths(self.group_actors)
def plot_obstacles(self):
for s in self.scene.get_obstacles():
self.ax.plot(s[:, 0], s[:, 1], "-o", color="black", markersize=2.5)
def animation_init(self):
self.plot_obstacles()
self.ax.add_collection(self.group_collection)
self.ax.add_collection(self.human_collection)
return (self.group_collection, self.human_collection)
def animation_update(self, i):
self.plot_groups(i)
self.plot_human(i)
return (self.group_collection, self.human_collection)
def plot_fibonacci_spiral(
number_of_squares,
numbers=True,
arc=True,
cmap="Blues",
alpha=1,
golden_ratio=False,
filename="plot.png",
):
"""Short summary.
Parameters
----------
number_of_squares : type
Description of parameter `number_of_squares`.
numbers : type
Description of parameter `numbers`.
arc : type
Description of parameter `arc`.
cmap : type
Description of parameter `cmap`.
alpha : type
Description of parameter `alpha`.
golden_ratio : type
Description of parameter `golden_ratio`.
Returns
-------
type
Description of returned object.
"""
fibs = list(fib(number_of_squares))
x = 0
y = 0
angle = 180
center = (x + fibs[0], y + fibs[0])
rectangles = []
xs, ys = [], []
fig, ax = plt.subplots(1, figsize=(16, 16))
for i, side in enumerate(fibs):
rectangles.append(Rectangle([x, y], side, side))
if numbers and i > number_of_squares - 8:
ax.annotate(side,
xy=(x + 0.45 * side, y + 0.45 * side),
fontsize=14)
if arc:
this_arc = Arc(
center,
2 * side,
2 * side,
angle=angle,
theta1=0,
theta2=90,
edgecolor="black",
antialiased=True,
)
ax.add_patch(this_arc)
angle += 90
xs.append(x)
ys.append(y)
if i == 0:
x += side
center = (x, y + side)
elif i == 1:
x -= side
y += side
center = (x, y)
elif i in range(2, i + 1, 4):
x -= side + previous_side
y -= previous_side
center = (x + side + previous_side, y)
elif i in range(3, i + 1, 4):
y -= side + previous_side
center = (x + side + previous_side, y + side + previous_side)
elif i in range(4, i + 1, 4):
x += side
center = (x, y + side + previous_side)
elif i in range(5, i + 1, 4):
x -= previous_side
y += side
center = (x, y)
previous_side = side
col = PatchCollection(rectangles, alpha=alpha, edgecolor="black")
try:
col.set(array=np.asarray(range(number_of_squares + 1)), cmap=cmap)
except ValueError:
print(f" '{cmap}' is an invalid colormap, choose a valid one from "
"https://matplotlib.org/examples/color/colormaps_reference.html"
" - returning to default 'Blues' colormap")
col.set(array=np.asarray(range(number_of_squares + 1)), cmap="Blues")
ax.add_collection(col)
ax.set_aspect("equal", "box")
ax.set_xticks([])
ax.set_yticks([])
xmin = np.min(xs)
ymin = np.min(ys)
xmax = np.max(xs) + fibs[np.argmax(xs)]
ymax = np.max(ys) + fibs[np.argmax(ys)]
ax.set_xlim(xmin, xmax)
ax.set_ylim(ymin, ymax)
gr = str(fibs[i] / fibs[i - 1])
if golden_ratio:
plt.title(r"$\varphi$ = " + gr)
plt.tight_layout()
plt.savefig(filename)
collection = PatchCollection([Polygon(face) for face in face_coords])
ax.add_collection(collection)
dataset = data_keys[i - 1]
data = data_collection[dataset]["values"]
cmap = data_collection[dataset]["cmap"]
bins = data_collection[dataset].get("bins")
if bins:
bins = np.amax(data) + 1
ticks = range(bins)
cmap = plt.get_cmap(cmap, lut=bins)
collection.set(array=data, cmap=cmap, edgecolor=None)
if bins:
plt.colorbar(collection, label=dataset, ticks=ticks, aspect=50)
else:
plt.colorbar(collection, label=dataset, aspect=50)
# add contour plots
# contours = PolyCollection(contour_coords, closed=False, linewidth=1.0, facecolors='none')
# ax.add_collection(contours)
title = "K: {}/ Epochs: {} / MSE: {}".format(n_clusters, epochs,
round(mse_loss, 2))
ax.set_title(title)
ax.set_aspect("equal")
import matplotlib.pyplot as plt
from matplotlib.collections import PatchCollection
from matplotlib.patches import Rectangle
import numpy as np
N = 100 # Number of rectangles
x_list = np.random.random(N)
y_list = np.random.random(N)
w_list = 0.1 * np.random.random(N)
h_list = 0.1 * np.random.random(N)
patches = []
x_list = [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
y_list = [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
w_list = [0.1] * 10
h_list = [0.1] * 10
for x, y, w, h in zip(x_list, y_list, w_list, h_list):
rectangle = Rectangle((x, y), w, h)
patches.append(rectangle)
fig = plt.figure()
ax = fig.add_subplot(111)
col = PatchCollection(patches, cmap=cm.jet, alpha=0.4)
col.set(array=np.array(x_list), cmap='jet')
ax.add_collection(col)
plt.colorbar(col)
plt.show()
def plot_array(self, a, masked_values=None, **kwargs):
"""
Plot an array. If the array is three-dimensional, then the method
will plot the layer tied to this class (self.layer).
Parameters
----------
a : numpy.ndarray
Array to plot.
masked_values : iterable of floats, ints
Values to mask.
**kwargs : dictionary
keyword arguments passed to matplotlib.pyplot.pcolormesh
Returns
-------
quadmesh : matplotlib.collections.QuadMesh or
matplotlib.collections.PatchCollection
"""
if not isinstance(a, np.ndarray):
a = np.array(a)
if self.mg.grid_type == "structured":
if a.ndim == 3:
plotarray = a[self.layer, :, :]
elif a.ndim == 2:
plotarray = a
elif a.ndim == 1:
plotarray = a
else:
raise Exception('Array must be of dimension 1, 2, or 3')
elif self.mg.grid_type == "vertex":
if a.ndim == 2:
plotarray = a[self.layer, :]
elif a.ndim == 1:
plotarray = a
else:
raise Exception('Array must be of dimension 1 or 2')
elif self.mg.grid_type == "unstructured":
plotarray = a
else:
raise TypeError("Unrecognized grid type {}".format(
self.mg.grid_type))
if masked_values is not None:
for mval in masked_values:
plotarray = np.ma.masked_equal(plotarray, mval)
if 'ax' in kwargs:
ax = kwargs.pop('ax')
else:
ax = self.ax
if self.mg.grid_type in ("structured", "vertex"):
xgrid = np.array(self.mg.xvertices)
ygrid = np.array(self.mg.yvertices)
if self.mg.grid_type == "structured":
quadmesh = ax.pcolormesh(xgrid, ygrid, plotarray)
else:
patches = [
Polygon(list(zip(xgrid[i], ygrid[i])), closed=True)
for i in range(xgrid.shape[0])
]
quadmesh = PatchCollection(patches)
quadmesh.set_array(plotarray)
else:
quadmesh = plotutil.plot_cvfd(self.mg._vertices,
self.mg._iverts,
a=a,
ax=ax)
# set max and min
if 'vmin' in kwargs:
vmin = kwargs.pop('vmin')
else:
vmin = None
if 'vmax' in kwargs:
vmax = kwargs.pop('vmax')
else:
vmax = None
quadmesh.set_clim(vmin=vmin, vmax=vmax)
# send rest of kwargs to quadmesh
quadmesh.set(**kwargs)
# add collection to axis
ax.add_collection(quadmesh)
# set limits
ax.set_xlim(self.extent[0], self.extent[1])
ax.set_ylim(self.extent[2], self.extent[3])
return quadmesh
