def initiate(self):
self.f, self.a = plt.subplots()
self.f.autofmt_xdate()
# self.at = self.a.twinx()
self.plot_active_d1()
self.plot_active_d2()
self.update_xlim()
self.event_handling()
out = self.controller.database.get_all_flights()
for idx, flight in out.iterrows():
self.controller.view.plot.plot_flight_duration(
flight.start, flight.end, flight.alt, flight.alt_source)
custom_lines = [
plt.Line2D([0], [0], color=colors[0], alpha=0.3, lw=5),
plt.Line2D([0], [0], color=colors[1], alpha=0.3, lw=5),
plt.Line2D([0], [0], color='0.5', alpha=0.3, lw=5),
]
# fig, ax = plt.subplots()
# lines = self..plot(data)
legend_source = self.a.legend(custom_lines, ['gps', 'baro', 'bad'],
loc=1)
self.a.legend(loc=2)
self.a.add_artist(legend_source)
self.a.grid(True)
return self.a, None #self.at
def plot_pie_network(model, path, t=20, xylim=None, show_landcover_pies=True, annotation=None):
fig, node_size = prepare_network_fig(model, model.pars["network_type"], xylim=xylim)
P_traj = model.sv_traj.T[::model.dim]
# q_traj = self.sv_traj.T[1::5]
# k_traj = self.sv_traj.T[2::5]
F_traj = model.sv_traj.T[3::model.dim]
S_traj = model.sv_traj.T[4::model.dim]
if show_landcover_pies:
node_pos = list(model.node_pos.values())
for node in range(model.no_agents):
draw_pie([F_traj[node][t], P_traj[node][t], S_traj[node][t]], center=node_pos[node],
radius=model.plot_pars["pie_radius"], startangle=90, width=0.8 * model.plot_pars["pie_radius"],
colors=('darkgreen', 'lawngreen', 'm'))
nx.draw_networkx_edges(model.G, model.node_pos, alpha=0.2)
strategy_cmap = matplotlib.colors.LinearSegmentedColormap.from_list('mycmap', [(0, 'darkblue'), (1, 'darkred')])
# because mapping does not work if there is no node with strategy 0:
if sum(model.strategy_traj[t]) == model.no_agents:
strategy_cmap = matplotlib.colors.LinearSegmentedColormap.from_list('mycmap', [(0, 'darkred'), (1, 'darkred')])
nx.draw_networkx_nodes(model.G, model.node_pos, node_color=model.strategy_traj[t], node_size=node_size,
cmap=strategy_cmap)
if annotation is not None:
plt.annotate(annotation, xy=(0, 1), xycoords='axes fraction', fontsize=36,
xytext=(5, -5), textcoords='offset points',
horizontalalignment='left', verticalalignment='top')
circle1 = plt.Line2D((0, 1), (0, 0), marker='o', linestyle='', markersize=12,
color="darkblue", label='Extensive Strategy')
circle2 = plt.Line2D((0, 1), (0, 0), marker='o', linestyle='', markersize=12,
color="darkred", label='Intensive Strategy')
legend_handles = [circle1, circle2]
if show_landcover_pies:
fpatch = matplotlib.patches.Patch(facecolor='darkgreen', edgecolor='k', label='Forest')
ppatch = matplotlib.patches.Patch(facecolor='lawngreen', edgecolor='k', label='Pasture')
svpatch = matplotlib.patches.Patch(facecolor='m', edgecolor='k', label='Sec. Vegetation')
legend_handles.append([fpatch, ppatch, svpatch])
plt.legend(handles=legend_handles, loc='lower left', prop={'size': 24})
plt.tight_layout()
plt.axis('off')
plt.savefig(path, dpi=model.plot_pars["dpi_saving"])
plt.clf()
plt.close(fig)
return 0
def plot_generated_toy_batch(X_real, generator_model, discriminator_model, noise_dim, gen_iter, noise_scale=0.5):
# Generate images
X_gen = sample_noise(noise_scale, 10000, noise_dim)
X_gen = generator_model.predict(X_gen)
# Get some toy data to plot KDE of real data
data = load_toy(pts_per_mixture=200)
x = data[:, 0]
y = data[:, 1]
xmin, xmax = -1.5, 1.5
ymin, ymax = -1.5, 1.5
# Peform the kernel density estimate
xx, yy = np.mgrid[xmin:xmax:100j, ymin:ymax:100j]
positions = np.vstack([xx.ravel(), yy.ravel()])
values = np.vstack([x, y])
kernel = stats.gaussian_kde(values)
f = np.reshape(kernel(positions).T, xx.shape)
# Plot the contour
fig = plt.figure(figsize=(10,10))
plt.suptitle("Generator iteration %s" % gen_iter, fontweight="bold", fontsize=22)
ax = fig.gca()
ax.contourf(xx, yy, f, cmap='Blues', vmin=np.percentile(f,80), vmax=np.max(f), levels=np.linspace(0.25, 0.85, 30))
# Also plot the contour of the discriminator
delta = 0.025
xmin, xmax = -1.5, 1.5
ymin, ymax = -1.5, 1.5
# Create mesh
XX, YY = np.meshgrid(np.arange(xmin, xmax, delta), np.arange(ymin, ymax, delta))
arr_pos = np.vstack((np.ravel(XX), np.ravel(YY))).T
# Get Z = predictions
ZZ = discriminator_model.predict(arr_pos)
ZZ = ZZ.reshape(XX.shape)
# Plot contour
ax.contour(XX, YY, ZZ, cmap="Blues", levels=np.linspace(0.25, 0.85, 10))
dy, dx = np.gradient(ZZ)
# Add streamlines
# plt.streamplot(XX, YY, dx, dy, linewidth=0.5, cmap="magma", density=1, arrowsize=1)
# Scatter generated data
plt.scatter(X_gen[:1000, 0], X_gen[:1000, 1], s=20, color="coral", marker="o")
l_gen = plt.Line2D((0,1),(0,0), color='coral', marker='o', linestyle='', markersize=20)
l_D = plt.Line2D((0,1),(0,0), color='steelblue', linewidth=3)
l_real = plt.Rectangle((0, 0), 1, 1, fc="steelblue")
# Create legend from custom artist/label lists
# bbox_to_anchor = (0.4, 1)
ax.legend([l_real, l_D, l_gen], ['Real data KDE', 'Discriminator contour',
'Generated data'], fontsize=18, loc="upper left")
ax.set_xlim(xmin, xmax)
ax.set_ylim(ymin, ymax + 0.8)
plt.savefig("../../figures/toy_dataset_iter%s.jpg" % gen_iter)
plt.clf()
plt.close()
def plot_position(result_a, t_a, positions):
z_quad_a = result_a[0, :]
x_quad_a = result_a[2, :]
alpha_a = result_a[4, :]
L = 0.5
z_mass_a = z_quad_a - L * np.cos(alpha_a)
x_mass_a = x_quad_a - L * np.sin(alpha_a)
plt.title("Path Followed by Quadrotor")
plt.plot(x_mass_a, z_mass_a, label='Mass', ls='--', lw=0.5)
plt.plot(x_quad_a,
z_quad_a,
label='Quadrotor',
ls='--',
color='tab:blue',
lw=0.5)
for p in positions:
link = plt.Line2D((x_quad_a[p], x_mass_a[p]),
(z_quad_a[p], z_mass_a[p]),
lw=0.5,
color='k')
plt.gca().add_line(link)
mass = plt.Circle((x_mass_a[p], z_mass_a[p]), 0.07, fc='k')
plt.gca().add_patch(mass)
plt.xlabel('X Position')
plt.ylabel('Y Position')
def plot_image_with_bboxes(im, bboxes):
fig = plt.figure(figsize=(6, 6))
plt.imshow(im, cmap='Greys')
bboxes = get_bboxes(im)
for (b_xs, b_ys) in bboxes:
Xs = [b_xs[0], b_xs[0], b_xs[1], b_xs[1], b_xs[0]]
Ys = [b_ys[0], b_ys[1], b_ys[1], b_ys[0], b_ys[0]]
line = plt.Line2D(Ys, Xs, color='red', linestyle='solid')
fig.add_subplot(111).add_artist(line)
def draw_rois(ROIs, axes, c):
i = 0
for (x, y) in ROIs:
l = plt.Line2D(y + [y[0]], x + [x[0]], color=c)
axes.text(np.max(y) - 5,
np.min(x) + 7,
str(i),
fontsize=10,
color=c,
bbox=dict(facecolor='w', alpha=0.))
axes.add_line(l)
i = i + 1
def plot_image_with_bboxes(im_to_plot, im_to_gen_bboxes):
fig = plt.figure(figsize=(6, 6))
plt.imshow(im_to_plot)
bboxes = evaluate_results.get_bboxes(im_to_gen_bboxes)
for (b_xs, b_ys) in bboxes:
Xs = [b_xs[0], b_xs[0], b_xs[1], b_xs[1], b_xs[0]]
Ys = [b_ys[0], b_ys[1], b_ys[1], b_ys[0], b_ys[0]]
line = plt.Line2D(Ys, Xs, color='red', linestyle='solid')
fig.add_subplot(111).add_artist(line)
plt.show()
def draw_rois(self):
i = 0
for (x, y) in self.ROIs:
# NOTE: x and y coordinates are exchanged!!
# imshow and Line2D assume different coordinate arrangements!!
l = plt.Line2D(y + [y[0]], x + [x[0]], color=self.cmap[i, :])
self.axes.text(np.max(y) - 5,
np.min(x) + 7,
str(i),
fontsize=10,
color=self.cmap[i, :],
bbox=dict(facecolor='w', alpha=0.))
self.axes.add_line(l)
i = i + 1
def plot_n_by_run(self, y, lbl=None, ax=None):
plt.rc('text', usetex=True)
plt.rc('font', family='serif', size=16)
mrk = ('o', 's', 'v', '^', '<', '>')
nmrk = len(mrk)
if ax is None:
fig = plt.figure(figsize=(10, 6))
ax = fig.gca()
grps = np.array(self.grps)
i = np.arange(len(self.runs)) + np.array(grps)
vmx = float("-inf")
for j in range(len(y)):
if lbl is not None:
l = lbl[j]
else:
l = None
ax.stem(i,
y[j],
linefmt="C%d" % j,
markerfmt="C%d" % j + mrk[j % nmrk],
basefmt="None",
label=l)
m = np.max(y[j])
vmx = max(m, vmx)
for j in range(np.max(grps) + 1):
k, = np.where(grps == j)
k += grps[k]
k0, kn = k[0], k[-1]
ax.add_line(
plt.Line2D([k0, kn], [0.] * 2, c="C%d" % j, linewidth=5))
ax.set_xticks(i)
ax.set_xticklabels(self.runs)
ax.set_xlabel("run")
ax.tick_params("x", labelrotation=90)
def draw_path(u, v, arrow_length=.1, color=(.8, .8, .8), lw=1):
du = u.direction
#plt.arrow(u.pose[X], u.pose[Y], du[0] * arrow_length, du[1] * arrow_length,
# head_width=.05, head_length=.1, fc=color, ec=color)
dv = v.direction
#plt.arrow(v.pose[X], v.pose[Y], dv[0] * arrow_length, dv[1] * arrow_length,
# head_width=.05, head_length=.1, fc=color, ec=color)
center, radius = find_circle(u, v)
du = u.position - center
theta1 = np.arctan2(du[1], du[0])
dv = v.position - center
theta2 = np.arctan2(dv[1], dv[0])
# Check if the arc goes clockwise.
if np.cross(u.direction, du).item() > 0.:
theta1, theta2 = theta2, theta1
#ax.add_patch(patches.Arc(center, radius * 2., radius * 2.,
# theta1=theta1 / np.pi * 180., theta2=theta2 / np.pi * 180.,
# color=color, lw=lw))
line = plt.Line2D(tuple([u.position[0], v.position[0]]),
tuple([u.position[1], v.position[1]]),
color=color,
lw=lw)
ax.add_line(line)
def _get_camera(self, plane, **kargs):
x0 = self.__params['r'] * (np.sin(self.__params['t'] * np.pi / 180.) *
np.cos(self.__params['p'] * np.pi / 180.))
y0 = self.__params['r'] * np.sin(self.__params['p'] * np.pi / 180.)
z0 = self.__params['r'] * (np.cos(self.__params['t'] * np.pi / 180.) *
np.cos(self.__params['p'] * np.pi / 180.))
xcam = self.__params['x'] + x0
ycam = self.__params['y'] + y0
zcam = self.__params['z'] + z0
if (plane == 'xy'):
camera = plt.Line2D([xcam], [ycam],
c='m',
marker='o',
markersize=15,
**kargs)
arrow = plt.Line2D([xcam, self.__params['x']],
[ycam, self.__params['y']],
lw=5)
elif (plane == 'xz'):
camera = plt.Line2D([xcam], [zcam],
c='m',
marker='o',
markersize=15,
**kargs)
arrow = plt.Line2D([xcam, self.__params['x']],
[zcam, self.__params['z']],
lw=5)
elif (plane == 'yz'):
camera = plt.Line2D([ycam], [zcam],
c='m',
marker='o',
markersize=15,
**kargs)
arrow = plt.Line2D([ycam, self.__params['y']],
[zcam, self.__params['z']],
lw=5)
else:
print('Incorrect plane:', plane)
print("Possibles planes are: 'xy';'xz';'yz'")
return
return camera, arrow
def _plot_dots(self):
# plt.plot(self.reward_position[0],self.reward_position[1],'ro',markersize=15,label='reward')
circle1 = plt.Circle((self.reward_position[0], self.reward_position[1]), self.reward_radius, color='r',
alpha=0.6)
plt.gca().add_artist(circle1)
pl = plt.Line2D([0.1], [0.1], color='g', markersize=10., marker='o', linewidth=0)
plt.gca().add_artist(pl)
handlers = [pl, circle1]
labels = ['initial position', 'goal']
if self.obstacle:
# plt.plot(self.obstacle_position[0],self.obstacle_position[1],'bo',markersize=15,label='obstacle')
circle2 = plt.Circle((self.obstacle_position[0], self.obstacle_position[1]), self.reward_radius, color='b',
alpha=0.6)
plt.gca().add_artist(circle2)
handlers.append(circle2)
labels.append('obstacle')
plt.legend(handlers, labels, bbox_to_anchor=(0., 1.02, 1., .102), loc=3,
ncol=3, mode="center", borderaxespad=0.)
recordings_noise = []
for n in noise_levels:
print('noise level:', n)
params['recordings']['noise_level'] = n
params['recordings']['seed'] = np.random.randint(1000)
recgen = mr.gen_recordings(tempgen=tempgen, params=params)
recordings_noise.append(recgen)
fig1 = plt.figure(figsize=(12, 14))
ax_noise = fig1.add_subplot(111)
for i, rec in enumerate(recordings_noise):
ax_noise = mr.plot_recordings(rec, colors=colors[i], ax=ax_noise, lw=0.2, start_time=1, end_time=2)
legend_lines = [plt.Line2D([0], [0], color=colors[0], lw=2),
plt.Line2D([0], [0], color=colors[1], lw=2),
plt.Line2D([0], [0], color=colors[2], lw=2),
plt.Line2D([0], [0], color=colors[3], lw=2)]
ax_noise.legend(handles=legend_lines, labels=['30 $\mu$V', '20 $\mu$V', '10 $\mu$V', '5 $\mu$V'],
fontsize=15, loc='upper right')
y_lim = ax_noise.get_ylim()
x_lim = ax_noise.get_xlim()
ts_lim = (x_lim[1] - x_lim[0]) // 3
ax_noise.plot([x_lim[0], x_lim[0] + 0.2 * ts_lim],
[np.min(y_lim) + 0.12 * np.abs(np.min(y_lim)),
np.min(y_lim) + 0.12 * np.abs(np.min(y_lim))], 'k', lw=2)
ax_noise.text(x_lim[0] + 0.01 * ts_lim, np.min(y_lim) + 0.05 * np.abs(np.min(y_lim)), '200 ms')
def plot_many(bins,
linestyles,
bin_labels,
age_then=None,
z_func=None,
colors=None,
**kwargs):
import numpy as np
import matplotlib.pylab as plt
from seren3.array import SimArray
from seren3.utils.plot_utils import ncols
ax1 = plt.gca()
legendArtists = []
for i in range(len(bins)):
ls = linestyles[i]
plot_mean_integrated_fesc(bins[i], linestyle=ls, colors=colors,\
label=False, legend=False, **kwargs)
legendArtists.append(
plt.Line2D((0, 1), (0, 0), color='k', linestyle=ls))
handles, labels = ax1.get_legend_handles_labels()
display = tuple(range(len(bins[0])))
ax1.set_xlim(0.2, 0.7)
# Shrink current axis's height by 10% on the bottom
box = ax1.get_position()
ax1.set_position(
[box.x0, box.y0 + box.height * 0.1, box.width, box.height * 0.9])
# Put a legend below current axis
legend_kwargs = {"title" : r"log$_{10}$(Mvir)", "loc" : "upper center", \
"bbox_to_anchor" : (0.5, -0.1), "fancybox" : True, "shadow" : True, "ncol" : 4}
ax1.legend([handle for i,handle in enumerate(handles) if i in display]+legendArtists,\
[label for i,label in enumerate(labels) if i in display]+bin_labels, **legend_kwargs)
# Redshift axis
if (z_func is not None) and (age_then is not None):
ax2 = ax1.twiny()
ax2.set_position(
[box.x0, box.y0 + box.height * 0.1, box.width, box.height * 0.9])
def tick_function(X):
# return ["%1.1f" % i for i in z_func( age_now - X )]
# We've scaled the x-axis by the age of halos, so need
# to account for zero-point in age
return ["%1.1f" % i for i in z_func(SimArray(X + age_then, "Gyr"))]
xtickpos = ax1.get_xticks()
print xtickpos
new_tick_locations = np.linspace(0.215, 0.685, 5)
print new_tick_locations
# new_tick_locations = np.array(ax1.get_xticks())
ax2.set_xlim(ax1.get_xlim())
ax2.set_xticks(new_tick_locations)
ax2.set_xticklabels(tick_function(new_tick_locations))
ax2.set_xlabel(r"Redshift")
ax1.set_xlabel(r"t$_{\mathrm{H}}$ [Gyr]")
ax1.set_ylabel(
r"$\langle \mathrm{f}_{\mathrm{esc}} \rangle$ (<t$_{\mathrm{H}}$ [%])")
stack = []
info = []
lines = []
for i in (1, 2):
# read image from file
filename = '../tests/qseries%d.tif' % i
stack.append(tiff.imread(filename))
# info for image
info.append({
'desc': 'WQStackBrowser: ' + filename,
'filename': filename,
'xperchan': 4.,
'yperchan': 64.
})
# additional line plots
y = np.arange(150, 4096)
l1 = plt.Line2D(np.poly1d(coeff[i - 1][0])(y), y, color='r', ls='-')
l2 = plt.Line2D(np.poly1d(coeff[i - 1][1])(y), y, color='g', ls='-')
lines.append([l1, l2])
# show single image
IB = WQBrowser(stack[0], {'desc': 'WQBrowser'}, aspect='auto', verbosity=4)
# show image stack
IB = WQStackBrowser(stack, info, lines, verbosity=4)
plt.show()
def draw_current_roi(self):
# NOTE: x and y exchanged!
l = plt.Line2D(self.curr_roi_y, self.curr_roi_x, color='r', marker='.')
self.axes.add_line(l)
frames=dp,
interval=0,
blit=True)
# Label the axes
ax.set_xlabel('x [Mpc]')
ax.set_ylabel('y [Mpc]')
ax.set_zlabel('z [Mpc]')
# Add a title to the plot
plt.title(str(N) + '-Body Simulation', size=18)
# Set Plot Legend
pos_mass = plt.Line2D([0], [0],
linestyle="none",
c='b',
marker='.',
label='+ve Mass')
neg_mass = plt.Line2D([0], [0],
linestyle="none",
c='r',
marker='.',
label='-ve Mass')
ax.legend(handles=[pos_mass, neg_mass],
bbox_to_anchor=(0., 1.075),
loc=2,
borderaxespad=0.,
numpoints=1)
# Show the plot
plt.show()
def pnorm_ball_line(A=np.eye(2), mu=np.array([0,0]),p=2, N=128,color='r',linewidth=3): ''' Creates line objects. Show them with ax.add_line(ln) ''' dx,dy = pnorm_ball_points(A) ln = plt.Line2D(dx,dy, color=color, linewidth=linewidth) return ln
def draw(self,
directed=True,
layout="spring",
node_label_attr=None,
show_node_labels=True,
edge_label_attr=None,
show_edge_labels=True,
node_size=1600,
node_color='blue',
node_alpha=0.3,
node_text_size=12,
edge_color='blue',
edge_alpha=0.3,
edge_tickness=1,
edge_text_pos=0.3,
text_font='sans-serif',
ax=None):
"Plot of a NetworkX multi-graph instance"
graph = self.graph(directed=directed)
pos = getattr(nx, "{}_layout".format(layout))(graph)
node_labels = {}
edge_labels = {}
node_colors = set()
if show_node_labels:
for node, props in graph.nodes(data=True):
labels = props.pop('labels', [])
for label in labels:
node_colors.add(label)
if node_label_attr is None:
node_labels[node] = "$:{}$\n{}".format(
":".join(labels),
props.values()[0] if props else "",
)
else:
props_list = [
"{}: {}".format(k, v) for k, v in props.items()
]
node_labels[node] = "$:{}$\n{}".format(
":".join(labels), "\n".join(props_list))
node_color = []
node_colors = list(node_colors)
legend_colors = []
colors = plt.matplotlib.colors.ColorConverter().cache.items()
for color_name, color_rgb in colors[:len(node_colors)]:
node_color.append(color_rgb)
legend_colors.append(color_name)
if show_edge_labels:
for start, end, props in graph.edges(data=True):
if edge_label_attr is None:
edge_label = props.get("type", '')
else:
edge_label = props.get(edge_label_attr, '')
edge_labels[(start, end)] = edge_label
if not ax:
fig = plt.figure()
ax = fig.add_subplot(111)
nodes = nx.draw_networkx_nodes(graph,
pos=pos,
node_color=node_color,
node_size=node_size,
alpha=node_alpha,
ax=ax)
nx.draw_networkx_labels(graph,
pos=pos,
labels=node_labels,
font_size=node_text_size,
font_family=text_font,
ax=ax)
nx.draw_networkx_edges(graph,
pos=pos,
width=edge_tickness,
alpha=edge_alpha,
edge_color=edge_color,
ax=ax)
nx.draw_networkx_edge_labels(graph,
pos=pos,
edge_labels=edge_labels,
ax=ax)
ax.legend([
plt.Line2D([0], [0],
linestyle="none",
marker="o",
alpha=node_alpha,
markersize=10,
markerfacecolor=color) for color in legend_colors
],
node_colors,
loc=(-0.25, 1),
numpoints=1,
frameon=False)
ax.set_axis_off()
return graph, ax, nodes
def main():
markers = {'pfam': '8', 'cameo': 'p', 'cameo41': "*", 'membrane': "D"}
total_folds = {"Periscope": 0, "Modeller": 0}
for dataset in datasets:
scores = {}
ds = getattr(DATASETS, dataset)
for target in ds:
s = _get_scores(target)
if s is None:
continue
scores[target] = s
proteins = list(scores.keys())
def _check_score(s):
return scores[s]['modeller'] is not None
proteins = [s for s in proteins if _check_score(s)]
our_scores = np.array([scores[s]['ms_2'] for s in proteins])
modeller = np.array([scores[s]['modeller'] for s in proteins])
refs_scores = np.array([scores[s]['ref'] for s in proteins])
n_homs = np.array([scores[s]['n_homs'] for s in proteins])
n_homs = n_homs / 1000 # / (np.max(n_homs) / 20)
n_refs = np.array([float(scores[s]['n_refs']) for s in proteins])
n_refs = n_refs # / np.max(n_refs)
modeller_correct_fold = np.sum(np.array(modeller) > 0.5)
total_folds['Modeller'] += modeller_correct_fold
ms_correct_fold = np.sum(np.array(our_scores) > 0.5)
total_folds['Periscope'] += ms_correct_fold
LOGGER.info(
f'{dataset} (n = {len(modeller)}):\nModeller correct folds: {modeller_correct_fold}\nMs correct fold {ms_correct_fold}'
)
modeller_win = np.sum(
np.logical_and(
np.array(modeller) > 0.5,
np.array(our_scores) < 0.5))
ms_win = np.sum(
np.logical_and(
np.array(our_scores) > 0.5,
np.array(modeller) < 0.5))
LOGGER.info(
f'{dataset} (n = {len(modeller)}):\nModeller win: {modeller_win}\nMs win {ms_win}'
)
# color = np.array(['blue' if s>0.5 else 'red' for s in our_scores])
tt = np.where(np.logical_and(modeller > 0.5, our_scores > 0.5))
ft = np.where(np.logical_and(modeller < 0.5, our_scores > 0.5))
tf = np.where(np.logical_and(modeller > 0.5, our_scores < 0.5))
ff = np.where(np.logical_and(modeller < 0.5, our_scores < 0.5))
our_scores -= refs_scores
modeller -= refs_scores
sc1 = plt.scatter(our_scores[tt],
modeller[tt],
c=n_refs[tt],
marker=10,
label=dataset,
s=n_homs[tt],
cmap=plt.cm.get_cmap('Greys'))
sc = plt.scatter(our_scores[tt],
modeller[tt],
c=n_refs[tt],
marker=10,
label=dataset,
s=n_homs[tt],
cmap=plt.cm.get_cmap('Blues'))
plt.scatter(our_scores[ft],
modeller[ft],
c=n_refs[ft],
marker=11,
label=dataset,
s=n_homs[ft],
cmap=plt.cm.get_cmap('Blues'))
plt.scatter(our_scores[tf],
modeller[tf],
c=n_refs[tf],
marker=10,
label=dataset,
s=n_homs[tf],
cmap=plt.cm.get_cmap('Reds'))
plt.scatter(our_scores[ff],
modeller[ff],
c=n_refs[ff],
marker=11,
label=dataset,
s=n_homs[ff],
cmap=plt.cm.get_cmap('Reds'))
plt.xlim([-1, 1])
plt.ylim([-1, 1])
for i, s in enumerate(proteins):
if True: # dataset != 'membrane':
dx = our_scores[i] - scores[s]['ref']
dy = modeller[i] - scores[s]['ref']
start = (scores[s]['ref'], dx)
end = (scores[s]['ref'], dy)
# plt.arrow(start[0], end[0], start[1], end[1], linestyle=(0, (1, 10)),
# color=color[i])
# if our_scores[i] > 0.5 and modeller[i] > 0.5:
# continue
# plt.annotate(s, (our_scores[i], modeller[i]), size=6)
plt.plot([-1, 1], [-1, 1], '--', c='black', alpha=0.3)
# plt.plot([0.5, 0.5], [0, 1], '--', c='black', alpha=0.3)
# plt.plot([0, 1], [0.5, 0.5], '--', c='black', alpha=0.3)
legend_elements = [
plt.Line2D([0], [0],
marker='o',
color='blue',
label='Periscope > 0.5',
linestyle='None'),
plt.Line2D([0], [0],
marker='o',
color='red',
label='Periscope < 0.5',
linestyle='None'),
plt.Line2D([0], [0],
marker=11,
color='black',
label='Modeller < 0.5',
linestyle='None'),
plt.Line2D([0], [0],
marker=10,
color='black',
label='Modeller > 0.5',
linestyle='None')
]
plt.xlabel("Our Method - Ref")
plt.ylabel("Modeller - Ref")
cb = plt.colorbar(sc1)
cb.ax.get_yaxis().labelpad = 25
cb.ax.set_ylabel('# of templates', rotation=270)
plt.legend(handles=[mpatches.Patch(color='black', label='Type1')])
legend1 = plt.legend(legend_elements, [
"Periscope > 0.5", "Periscope < 0.5", "Modeller < 0.5",
"Modeller > 0.5"
],
loc=2,
fontsize=6,
fancybox=True)
plt.legend(*sc.legend_elements("sizes", num=6),
loc=3,
fancybox=True,
title='MSA depth\n(Thousends)',
fontsize=6)
plt.gca().add_artist(legend1)
# plt.legend(loc='upper left')
plt.title(f'{dataset}')
plt.savefig(
os.path.join(PATHS.periscope, 'data', 'figures',
f'tm_scores_{dataset}.png'))
plt.close()
LOGGER.info(f'Total folds:\n{total_folds}')
def fit_aperture_borders(self, order=2, log=False, **kwargs):
"""
Determine the left and right border of the aperture as polynom x(y)
for the series of E-q maps.
order ... (opt) order of the polynomial to fit
log ... (opt) consider aperture images on log-scale
for further options, see fit_border.get_border_points()
RETURNS list of tuples(left,right) containing polynomials x = left(y)
"""
self.ap_order = order
self.ap_log = log
# illumination reference (smoothed version)
if self.ref_name is not None:
ref = np.abs(gaussfilt1D(self.ref_img, 11))
# gauss-filter
#ref = np.abs(lorentzfit1D(self.ref_img,offset=offset)); # fit lorentz
ref[ref < np.mean(ref)] = np.mean(ref)
# constant for low values
# to avoid 0 devision
if self.verbosity > 9:
self.__dbg_fig.append(self.plot_reference(ref))
# draw figure and save in list
else:
ref = 1
# no reference given
# iterate over all aperture images
points = []
fit = []
lines = []
stack = []
info = []
for i, image in enumerate(self.ap_stack):
# correct image by illu_ref
filtimg = image / ref
if log: filtimg = np.log(np.abs(filtimg) + 1)
# get aperture border as point list in px (correct for binning!)
c = self.crop
l, r = fit_border.get_border_points(
filtimg,
interp_out=True,
xmin=int(c['xmin'] / self.xbin),
xmax=int(c['xmax'] / self.xbin),
ymin=int(c['ymin'] / self.ybin),
ymax=int(c['ymax'] / self.ybin),
verbosity=self.verbosity - 10,
**kwargs)
l = ((l + 0.5).T * (self.xbin, self.ybin)).T
# convert to px, points (x,y)
r = ((r + 0.5).T * (self.xbin, self.ybin)).T
points.append([l, r])
# fit polynom x=p(y) to left and right border
polyl = np.poly1d(np.polyfit(l[1], l[0], order))
polyr = np.poly1d(np.polyfit(r[1], r[0], order))
fit.append((polyl, polyr))
# DEBUG: drawing fit points and polynoms
if self.verbosity > 2:
y = np.arange(self.crop['ymin'], self.crop['ymax'])
stack.append(filtimg)
info.append({
'desc': 'DEBUG: ' + self.ap_names[i],
'xperchan': self.xbin,
'yperchan': self.ybin
})
p1 = plt.Line2D(l[0], l[1], marker='x', ls='', c='b')
p2 = plt.Line2D(r[0], r[1], marker='x', ls='', c='b')
p3 = plt.Line2D(polyl(y), y, color='r')
p4 = plt.Line2D(polyr(y), y, color='r')
lines.append([p1, p2, p3, p4])
if self.verbosity > 2:
self.__dbg_fig.append(self.plot_aperture_images(
stack, info, lines))
# store results
self.ap_points = points
# contains Nap (l,r) tuples; l,r are a lists of (x,y) points
self.ap_poly = fit
# contains Nap (pl,pr) tuples; pl,pr are polynoms y(x)
# comments
self.history.append("Fit aperture borders")
self.history.append("|- order=%d, log=%s" % (order, log))
params = ", ".join(
[key + ": " + str(val) for key, val in kwargs.items()])
self.history.append("|- " + params)
return fit
def visualization(robot, pr, factor=7):
plt.figure("Robot in the world", figsize=(field.w_width, field.w_length))
plt.title('Particle filter')
# draw coordinate grid for plotting
grid = [
-field.w_width / 2.0, field.w_width / 2.0, -field.w_length / 2.0,
field.w_length / 2.0
]
ax = plt.axis(grid)
landmarks = {
"blue_posts": [[-1.0, -4.5], [1.0, -4.5]],
"yellow_posts": [[-1.0, 4.5], [1.0, 4.5]]
}
for el in field.field:
if el == 'circles':
for circle in field.field['circles']:
plot_circle = plt.Circle((circle[0], circle[1]),
circle[2],
linewidth=2,
fill=False,
edgecolor='#330000')
plt.gca().add_patch(plot_circle)
if el == 'lines':
for line in field.field['lines']:
plot_line = plt.Line2D(line[0],
line[1],
linewidth=2,
linestyle="-",
color='#330000')
plt.gca().add_line(plot_line)
if el == 'rectangles':
for rectangle in field.field['rectangles']:
rect = plt.Rectangle(rectangle[0],
rectangle[1],
rectangle[2],
linewidth=2,
linestyle="-",
fill=False,
edgecolor='#330000')
plt.gca().add_patch(rect)
'''
# draw particles
for ind in range(len(p)):
# particle
circle = plt.Circle((p[ind][0].x, p[ind][0].y), 1./factor/2, facecolor='#ffb266', edgecolor='#994c00', alpha=0.5)
plt.gca().add_patch(circle)
# particle's orientation
arrow = plt.Arrow(p[ind][0].x, p[ind][0].y, 2*math.cos(p[ind][0].yaw)/factor, 2*math.sin(p[ind][0].yaw)/factor, width=1/factor, alpha=1., facecolor='#994c00', edgecolor='#994c00')
plt.gca().add_patch(arrow)
'''
# draw resampled particles
for ind in range(len(pr)):
# particle
circle = plt.Circle((pr[ind][0].y, pr[ind][0].x),
1. / factor / 2,
facecolor='#ffb266',
edgecolor='#cc0000',
alpha=0.5)
plt.gca().add_patch(circle)
# particle's orientation
arrow = plt.Arrow(pr[ind][0].y,
pr[ind][0].x,
2 * math.sin(pr[ind][0].yaw) / factor,
math.cos(pr[ind][0].yaw) / factor,
width=1 / factor,
alpha=1.,
facecolor='#006600',
edgecolor='#006600')
plt.gca().add_patch(arrow)
# robot's location
circle = plt.Circle((robot.y, robot.x),
1. / factor,
facecolor='#FF66E9',
edgecolor='#FF66E9')
plt.gca().add_patch(circle)
# robot's orientation
arrow = plt.Arrow(robot.y,
robot.x,
3 * math.sin(robot.yaw) / factor,
3 * math.cos(robot.yaw) / factor,
width=1.0 / factor,
alpha=0.5,
facecolor='#000000',
edgecolor='#000000')
plt.gca().add_patch(arrow)
#fixed landmarks of known locations2
for lm in landmarks:
for lms in landmarks[lm]:
if lm == "yellow_posts":
circle = plt.Circle(((lms[0], lms[1])),
1. / factor,
facecolor='#ffff00',
edgecolor='#330000')
plt.gca().add_patch(circle)
else:
circle = plt.Circle(((lms[0], lms[1])),
1. / factor,
facecolor='#060C73',
edgecolor='#330000')
plt.gca().add_patch(circle)
def xkcd(
ax,
mag=1.0,
f1=50,
f2=0.01,
f3=15,
bgcolor='w',
title_size=None,
xaxis_loc=None,
yaxis_loc=None,
xaxis_arrow='+',
yaxis_arrow='+',
ax_extend=0.1,
xlabel_inside=0.,
ylabel_inside=0.,
ticks=False,
xticks_inside=0.,
yticks_inside=0.,
):
"""
Make axis look hand-drawn
This adjusts all lines, text, legends, and axes in the figure to look
like xkcd plots, a webcomic from Randall Munroe. Other plot elements are not modified.
Definition
----------
def xkcd(ax,
mag=1.0,
f1=50, f2=0.01, f3=15,
bgcolor='w',
title_size=None,
xaxis_loc=None, yaxis_loc=None,
xaxis_arrow='+', yaxis_arrow='+',
ax_extend=0.1,
xlabel_inside=0., ylabel_inside=0.,
ticks=False,
xticks_inside=0., yticks_inside=0.,
):
Input
-----
ax Axes instance the axes instance to be modified.
Optional Input
--------------
mag float; the magnitude of the distortion (default: 1.0)
f1, f2, f3 int, float, int; filtering parameters.
f1 gives the size of the window (default: 50)
f2 gives the high-frequency cutoff (default: 0.01)
f3 gives the size of the filter (default: 15)
bgcolor str; color around lines so that axis look brocken,
i.e. lines are overdrawn on axis (default: 'w')
titel_size float; poitn size of plot title. If None, same size as axis labels.
(default: None)
xaxis_loc, yaxis_log float; The locations to draw the x and y axes in data coordinates.
If not specified, they will be drawn from the bottom left of the plot.
(default: None)
xaxis_arrow, yaxis_arrow str; where to draw arrows on the x/y axes
Options are '+', '-', '+-', or '' (default: '+')
ax_extend float; How far (fractionally) to extend the drawn axes beyond
the original axes limits (default: 0.1)
xlabel_inside, ylabel_inside float: By how much the labels are shifted (default: 0.0)
The last two options are not working how with mc_plot_template
ticks True: change tick labels; False: no tick labels are drawn (default: False)
xticks_inside, yticks_inside float: By how much the ticks are shifted (default: 0.0)
Output
------
ax is basically empty and all former elements are redrawn on plot.
Note
----
For reproducible plots, seed the random number generator before each new plot.
If a new line was added, the old lines will look the same. The legend will be different though.
References
----------
This is the modified XKCD plot generator of Jake Vanderplas
http://nbviewer.ipython.org/url/jakevdp.github.com/downloads/notebooks/XKCD_plots.ipynb
The idea for this comes from work by Damon McDougall
http://www.mail-archive.com/[email protected]/msg25499.html
Examples
--------
import matplotlib.pylab as plt
fig = plt.figure(1)
ax = fig.add_axes([0.1,0.1,0.5,0.5])
ax.plot(range(10), label='Line')
ax.set_title('Title')
ax.set_xlabel('x label')
ax.set_ylabel('y label')
ax.legend()
xkcd(ax)
License
-------
This file is part of the JAMS Python package, distributed under the MIT License.
Copyright (c) 2013 Matthias Cuntz - mc (at) macu (dot) de
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
History
-------
Written, MC, Mar 2013
"""
import matplotlib.pylab as plt
import matplotlib.font_manager as fm
# remember random state for later resetting
random_state = np.random.get_state()
# Get axes aspect
ext = ax.get_window_extent().extents
aspect = (ext[3] - ext[1]) / (ext[2] - ext[0])
xlim = ax.get_xlim()
ylim = ax.get_ylim()
xspan = xlim[1] - xlim[0]
yspan = ylim[1] - xlim[0]
xax_lim = (xlim[0] - ax_extend * xspan, xlim[1] + ax_extend * xspan)
yax_lim = (ylim[0] - ax_extend * yspan, ylim[1] + ax_extend * yspan)
if xaxis_loc is None: xaxis_loc = ylim[0]
if yaxis_loc is None: yaxis_loc = xlim[0]
# Draw axes
acolor = ax.get_xaxis().get_gridlines()[0].get_color()
xaxis = plt.Line2D([xax_lim[0], xax_lim[1]], [xaxis_loc, xaxis_loc],
linestyle='-',
color=acolor)
yaxis = plt.Line2D([yaxis_loc, yaxis_loc], [yax_lim[0], yax_lim[1]],
linestyle='-',
color=acolor)
# adjust the axes
if ticks:
for x, xtext in zip(ax.get_xticks(), ax.get_xticklabels()):
ax.text(x,
xaxis_loc - 0.08 * yspan * (2 * xticks_inside - 1),
xtext.get_text(),
fontsize=xtext.get_size(),
ha='center',
va='bottom' if xticks_inside else 'top',
rotation=0)
for y, ytext in zip(ax.get_yticks(), ax.get_yticklabels()):
ax.text(yaxis_loc + 0.02 * xspan * (2 * yticks_inside - 1),
y,
ytext.get_text(),
fontsize=ytext.get_size(),
ha='left' if yticks_inside else 'right',
va='center',
rotation=0)
# Label axes
siz = ax.get_xaxis().get_label().get_size()
ax.text(xax_lim[1],
xaxis_loc - 0.2 * yspan * (2 * xlabel_inside - 1),
ax.get_xlabel(),
fontsize=siz,
ha='right',
va='bottom' if xlabel_inside else 'top',
rotation=0)
ax.text(yaxis_loc + 0.04 * xspan * (2 * ylabel_inside - 1),
yax_lim[1],
ax.get_ylabel(),
fontsize=siz,
ha='right',
va='bottom' if ylabel_inside else 'top',
rotation=84)
# Title - default: same size as axis labels
if title_size is not None:
siz2 = title_size
else:
siz2 = siz
ax.text(0.5 * (xax_lim[1] + xax_lim[0]),
yax_lim[1],
ax.get_title(),
ha='center',
va='bottom',
fontsize=siz2)
# Draw arrow-heads at the end of axes lines
arr1 = 0.04 * np.array([-1, 0, -1])
arr2 = 0.03 * np.array([-1, 0, 1])
arr1[::2] += np.random.normal(0, 0.005 / 2, 2)
arr2[::2] += np.random.normal(0, 0.005 / 2, 2)
x, y = xaxis.get_data()
if '+' in str(xaxis_arrow):
ax.plot(x[-1] + arr1 * xspan * aspect,
y[-1] + arr2 * yspan,
color=acolor,
lw=2)
if '-' in str(xaxis_arrow):
ax.plot(x[0] - arr1 * xspan * aspect,
y[0] - arr2 * yspan,
color=acolor,
lw=2)
x, y = yaxis.get_data()
if '+' in str(yaxis_arrow):
ax.plot(x[-1] + arr2 * xspan * aspect**2,
y[-1] + arr1 * yspan / aspect,
color=acolor,
lw=2)
if '-' in str(yaxis_arrow):
ax.plot(x[0] - arr2 * xspan * aspect**2,
y[0] - arr1 * yspan / aspect,
color=acolor,
lw=2)
# Set the axis limits
ax.set_xlim(xax_lim[0] - 0.1 * xspan, xax_lim[1] + 0.1 * xspan)
ax.set_ylim(yax_lim[0] - 0.1 * yspan, yax_lim[1] + 0.1 * yspan)
# The lines
Nlines = len(ax.lines)
lines = [xaxis, yaxis] + [ax.lines.pop(0) for i in range(Nlines)]
for line in lines:
x, y = line.get_data()
ls = line.get_linestyle()
if ls != 'None':
x_int, y_int = xkcd_line(x, y, xlim, ylim, mag, f1, f2, f3)
else:
x_int, y_int = x, y
# create foreground and background line
lw = line.get_linewidth()
line.set_linewidth(2 * lw)
line.set_data(x_int, y_int)
# White surrounding of line makes them look overplot on axis
if (line is not xaxis) and (line is not yaxis) and ls != 'None':
line_bg = plt.Line2D(x_int,
y_int,
color=bgcolor,
linewidth=2 * lw + 4)
ax.add_line(line_bg)
ax.add_line(line)
# Change all the fonts to humor-sans.
# from jams.find_in_path import find_in_path
# fhumor = find_in_path('Humor-Sans.ttf') # in jams_python
import os
fhumor = os.path.join(os.path.dirname(__file__),
'Humor-Sans.ttf') # in jams_python/jams
for text in ax.texts:
tsize = text.get_size()
prop = fm.FontProperties(fname=fhumor, size=tsize)
text.set_fontproperties(prop)
# modify legend
leg = ax.get_legend()
if leg is not None:
np.random.set_state(
random_state
) # restate random number generator for reproducible results
leg.set_frame_on(False)
for child in leg.get_children():
if isinstance(child, plt.Line2D):
x, y = child.get_data()
child.set_data(
xkcd_line(x, y, mag=10. * mag, f1=2 * f1, f2=f2 / 10.))
child.set_linewidth(2 * child.get_linewidth())
if isinstance(child, plt.Text):
tsize = child.get_size()
prop = fm.FontProperties(fname=fhumor, size=tsize)
child.set_fontproperties(prop)
# remove standard axis
ax.set_title('')
ax.set_xlabel('')
ax.set_ylabel('')
ax.set_xticks([])
ax.set_yticks([])
ax.set_axis_off()
return ax
def __line_between_two_neurons(self,
ax,
neuron1,
neuron2,
weight=0.4,
textoverlaphandler=None):
angle = atan((neuron2.x - neuron1.x) / float(neuron2.y - neuron1.y))
x_adjustment = self.neuron_radius * sin(angle)
y_adjustment = self.neuron_radius * cos(angle)
# assign colors to lines depending on the sign of the weight
color = Tableau_10.mpl_colors[0]
if weight > 0:
color = Tableau_10.mpl_colors[1]
# assign different linewidths to lines depending on the size of the
# weight
abs_weight = abs(weight)
if abs_weight > 0.5:
linewidth = 10 * abs_weight
elif abs_weight > 0.8:
linewidth = 100 * abs_weight
else:
linewidth = abs_weight
# draw the weights and adjust the labels of weights to avoid
# overlapping
if abs_weight > 0.5:
# while loop to determine the optimal locaton for text lables to
# avoid overlapping
index_step = 2
num_segments = 10
txt_x_pos = (
neuron1.x - x_adjustment + index_step *
(neuron2.x - neuron1.x + 2 * x_adjustment) / num_segments)
txt_y_pos = (
neuron1.y - y_adjustment + index_step *
(neuron2.y - neuron1.y + 2 * y_adjustment) / num_segments)
while (not textoverlaphandler.getspace([
txt_x_pos - 0.5,
txt_y_pos - 0.5,
txt_x_pos + 0.5,
txt_y_pos + 0.5,
])) and index_step < num_segments:
index_step = index_step + 1
txt_x_pos = (
neuron1.x - x_adjustment + index_step *
(neuron2.x - neuron1.x + 2 * x_adjustment) / num_segments)
txt_y_pos = (
neuron1.y - y_adjustment + index_step *
(neuron2.y - neuron1.y + 2 * y_adjustment) / num_segments)
# print("Label positions: ", "{:.2f}".format(txt_x_pos), "{:.2f}".format(txt_y_pos), "{:3.2f}".format(weight))
a = ax.text(
txt_x_pos,
txt_y_pos,
"{:3.2f}".format(weight),
size=8,
ha='center',
)
a.set_bbox(dict(facecolor='white', alpha=0))
# print(a.get_bbox_patch().get_height())
line = plt.Line2D(
(neuron1.x - x_adjustment, neuron2.x + x_adjustment),
(neuron1.y - y_adjustment, neuron2.y + y_adjustment),
linewidth=linewidth,
color=color,
)
ax.add_line(line)
recgen = mr.gen_recordings(tempgen=tempgen, params=params)
recordings_noise.append(recgen)
fig1 = plt.figure(figsize=(12, 14))
ax_noise = fig1.add_subplot(111)
for i, rec in enumerate(recordings_noise):
ax_noise = mr.plot_recordings(rec,
colors=colors[i],
ax=ax_noise,
lw=0.2,
start_time=1,
end_time=2)
legend_lines = [
plt.Line2D([0], [0], color=colors[0], lw=2),
plt.Line2D([0], [0], color=colors[1], lw=2),
plt.Line2D([0], [0], color=colors[2], lw=2),
plt.Line2D([0], [0], color=colors[3], lw=2)
]
ax_noise.legend(handles=legend_lines,
labels=['30 $\mu$V', '20 $\mu$V', '10 $\mu$V', '5 $\mu$V'],
fontsize=12,
loc='upper right')
y_lim = ax_noise.get_ylim()
x_lim = ax_noise.get_xlim()
ts_lim = (x_lim[1] - x_lim[0]) // 3
ax_noise.plot([x_lim[0], x_lim[0] + 0.2 * ts_lim], [
np.min(y_lim) + 0.12 * np.abs(np.min(y_lim)),
def draw(self,
directed=True,
layout="spring",
node_label_attr=None,
show_node_labels=True,
edge_label_attr=None,
show_edge_labels=True,
node_size=1600,
node_color='blue',
node_alpha=0.3,
node_text_size=12,
edge_color='blue',
edge_alpha=0.3,
edge_tickness=1,
edge_text_pos=0.3,
text_font='sans-serif',
ax=None):
"""Plot of a NetworkX multi-graph instance
:param directed: boolean, optional (default=`True`).
Whether to return a directed graph or not.
:param layout: string, optional (default=`"spring"`).
Layout to apply. Any of the possible NetworkX layouts will work:
``'circular_layout'``, ``'random_layout'``, ``'shell_layout'``,
``'spring_layout'``, ``'spectral_layout'``,
or ``'fruchterman_reingold_layout'``.
:param node_label_attr: string, optional (default=`None`).
Attribute of the nodes that has to be used as the label.
:param show_node_labels: boolean, optional (default=`True`).
Whether to show or not the labels of the nodes.
:param edge_label_attr: boolean, optional (default=`None`).
Attribute of the edges that has to be used as the label.
:param show_edge_labels: . optional (default=`True`).
Whether to show or not the labels of the edges.
:param node_size: integer, optional (default=`1600`).
Desired size for nodes.
:param node_color: color string, or array of floats, (default=`'blue'`)
Node color. Can be a single color format string, or a sequence of
colors with the same length as nodelist. If numeric values are
specified they will be mapped to colors using the ``cmap`` and
``vmin``, ``vmax`` parameters. See ``matplotlib.scatter`` for more
details.
:param node_alpha: float, optional (default=`0.3`).
Between 0 and 1 for transparency of nodes.
:param node_text_size: integer, optional (default=`12`).
Size of the node text.
:param edge_color: color string, or array of floats (default=`'blue'`)
Edge color. Can be a single color format string, or a sequence of
colors with the same length as edgelist. If numeric values are
specified they will be mapped to colors using the ``edge_cmap`` and
``edge_vmin``, ``edge_vmax`` parameters.
:param edge_alpha: float, optional (default=`0.3`)
Transparency for thee edges.
:param edge_tickness: float or integer, optional (default=`1`).
Thickness of the lines drawn for the edges.
:param edge_text_pos: . Default to optional (d0)=
:param text_font: . Default to optional (default=`'sans-serif'`).
:param ax: ``matplotlib.Figure``, optional (default=`None`).
A ``matplotlib.Figure`` to use when rendering the graph. If `None`,
a new object is created and returned.----
:return: a ``matplotlib.Figure`` with the graph rendered.
"""
graph = self.get_graph(directed=directed)
pos = getattr(nx, "{}_layout".format(layout))(graph)
node_labels = {}
edge_labels = {}
node_colors = set()
if show_node_labels:
for node, props in graph.nodes(data=True):
labels = props.pop('labels', [])
for label in labels:
node_colors.add(label)
if node_label_attr is None:
node_labels[node] = "$:{}$\n{}".format(
":".join(labels),
next(iter(props.values())) if props else "",
)
else:
props_list = [
"{}: {}".format(k, v) for k, v in props.items()
]
node_labels[node] = "$:{}$\n{}".format(
":".join(labels), "\n".join(props_list))
node_color = []
node_colors = list(node_colors)
legend_colors = []
colors = list(plt.matplotlib.colors.ColorConverter().cache.items())[2:]
for _, color_rgb in colors[:len(node_colors)]:
node_color.append(color_rgb)
legend_colors.append(color_rgb)
if show_edge_labels:
for start, end, props in graph.edges(data=True):
if edge_label_attr is None:
edge_label = props.get("type", '')
else:
edge_label = props.get(edge_label_attr, '')
edge_labels[(start, end)] = edge_label
if not ax:
fig = plt.figure()
ax = fig.add_subplot(111)
nodes = nx.draw_networkx_nodes(graph,
pos=pos,
node_color=node_color,
node_size=node_size,
alpha=node_alpha,
ax=ax)
nx.draw_networkx_labels(graph,
pos=pos,
labels=node_labels,
font_size=node_text_size,
font_family=text_font,
ax=ax)
nx.draw_networkx_edges(graph,
pos=pos,
width=edge_tickness,
alpha=edge_alpha,
edge_color=edge_color,
ax=ax)
nx.draw_networkx_edge_labels(graph,
pos=pos,
edge_labels=edge_labels,
ax=ax)
ax.legend([
plt.Line2D([0], [0],
linestyle="none",
marker="o",
alpha=node_alpha,
markersize=10,
markerfacecolor=color) for color in legend_colors
],
node_colors,
loc=(-0.25, 1),
numpoints=1,
frameon=False)
ax.set_axis_off()
return graph, ax, nodes
def save(self):
cmap = plt.cm.get_cmap('hsv', 10)
fig, ax = plt.subplots(figsize=(7, 7))
ax.tick_params(labelsize=16)
ax.set_xlim(-5, 5)
ax.set_ylim(-5, 5)
ax.set_xlabel('x(m)', fontsize=16)
ax.set_ylabel('y(m)', fontsize=16)
x_offset = 0.11
y_offset = 0.11
robot_color = 'yellow'
human_positions = [[state.position for state in states[1]]
for states in self.point_list]
human_num = len(human_positions[0])
human_radii = [state.radius for state in self.point_list[0][1]]
robot_positions = [states[0].position for states in self.point_list]
robot_radius = self.point_list[0][0].radius
episode_length = len(self.point_list)
time_step = .25
for k in range(episode_length):
if k % 4 == 0 or k == episode_length - 1:
robot = plt.Circle(robot_positions[k],
robot_radius,
fill=True,
color=robot_color)
humans = [
plt.Circle(human_positions[k][i],
human_radii[i],
fill=False,
color=cmap(i))
for i in range(len(human_positions[0]))
]
ax.add_artist(robot)
for human in humans:
ax.add_artist(human)
# add time annotation
global_time = k * time_step
if global_time % 4 == 0 or k == episode_length - 1:
agents = humans + [robot]
times = [
plt.text(agents[i].center[0] - x_offset,
agents[i].center[1] - y_offset,
'{:.1f}'.format(global_time),
color='black',
fontsize=14) for i in range(human_num + 1)
]
for time in times:
ax.add_artist(time)
if k != 0:
nav_direction = plt.Line2D(
(robot_positions[k - 1][0], robot_positions[k][0]),
(robot_positions[k - 1][1], robot_positions[k][1]),
color=robot_color,
ls='solid')
human_directions = [
plt.Line2D((human_positions[k - 1][i][0],
human_positions[k][i][0]),
(human_positions[k - 1][i][1],
human_positions[k][i][1]),
color=cmap(i),
ls='solid') for i in range(human_num)
]
ax.add_artist(nav_direction)
for human_direction in human_directions:
ax.add_artist(human_direction)
plt.legend([robot], ['Robot'], fontsize=16)
plt.savefig(self.file)
plt.close(fig)
