class BatchLineCollection(object):
def __init__(self, ax):
self._ax = ax
self._lc = None
@property
def artists(self):
return [self._lc]
def draw(self, x, y, **kwargs):
segments = []
for x_i, y_i in zip(x, y):
xy_i = np.stack([x_i, y_i], axis=1)
xy_i = xy_i.reshape(-1, 1, 2)
segments_i = np.hstack([xy_i[:-1], xy_i[1:]])
segments.append(segments_i)
segments = np.concatenate(segments, axis=0)
if self._lc is None:
self._lc = PltLineCollection(segments)
self._ax.add_collection(self._lc)
else:
self._lc.set_segments(segments)
if 'color' in kwargs:
self._lc.set_color(np.reshape(kwargs['color'],
[len(segments), -1]))
if 'linewidth' in kwargs:
self._lc.set_linewidth(kwargs['linewidth'])
self._lc.set_joinstyle('round')
self._lc.set_capstyle('round')
def changeVecteur(self, ech=1.0, col=None):
""" modifie les valeurs de vecteurs existants"""
self.drawVecteur(False)
if type(ech) == type((3, 4)):
if len(ech) >= 1:
ech = ech[0]
# previous object
obj = self.getObjFromType("vecteur")
if obj == None:
return
# change coordinates
dep, arr_old, ech_old = obj.getData()
arr = dep + (arr_old - dep) * ech / ech_old
# new object
lc1 = LineCollection(zip(dep, arr))
lc1.set_transform(self.transform)
if col == None:
col = wx.Color(0, 0, 255)
a = col.Get()
col = (a[0] / 255, a[1] / 255, a[2] / 255)
lc1.set_color(col)
obj = GraphicObject("vecteur", lc1, False, None)
obj.setData([dep, arr, ech])
self.addGraphicObject(obj)
self.cnv.collections[0] = lc1
self.redraw()
def plot_line_colored(x, y, t, w=None, color=None, cmap=None):
import numpy as np
from matplotlib.collections import LineCollection
# Create a set of line segments so that we can color them individually
# This creates the points as a N x 1 x 2 array so that we can stack points
# together easily to get the segments. The segments array for line collection
# needs to be numlines x points per line x 2 (x and y)
points = np.array([x, y]).T.reshape(-1, 1, 2)
segments = np.concatenate([points[:-1], points[1:]], axis=1)
extra = {}
if w is None: extra['linewidths'] = w
# Create the line collection object, setting the colormapping parameters.
# Have to set the actual values used for colormapping separately.
lc = LineCollection(segments,
cmap=p.get_cmap(cmap),
**extra
#norm=p.Normalize(0, 10)
)
lc.set_array(t)
lc.set_linewidth(w)
if color is not None:
lc.set_color(color)
p.gca().add_collection(lc)
def add_china_map_2basemap(ax,name ="province", facecolor='none',
edgecolor='c', lw=2, encoding='utf-8', **kwargs):
"""
Add china province boundary to basemap instance.
:param mp: basemap instance.
:param ax: matplotlib axes instance.
:param name: map name.
:param facecolor: fill color, default is none.
:param edgecolor: edge color.
:param lw: line width.
:param kwargs: keywords passing to Polygon.
:return: None.
"""
# map name
names = {'nation': "bou1_4p", 'province': "bou2_4p",
'county': "BOUNT_poly", 'river': "hyd1_4p",
'river_high': "hyd2_4p"}
# get shape file and information
shpfile = pkg_resources.resource_filename(
'meteva', "resources/maps/" + names[name])
shp1 = readshapefile(shpfile, default_encoding=encoding)
lines = LineCollection(shp1,antialiaseds=(1,))
lines.set_color(edgecolor)
lines.set_linewidth(lw)
lines.set_label('_nolabel_')
ax.add_collection(lines)
def plotcf(grid, phase, modulus, darken=None, axes=None, linestylep="solid", linewidthp=1, color="k", **kwargs):
r"""Plot the modulus of a complex valued function
:math:`f:\mathbb{R} \rightarrow \mathbb{C}`
together with its phase in a color coded fashion.
:param grid: The grid nodes of the real domain R
:param phase: The phase of the complex domain result f(grid)
:param modulus: The modulus of the complex domain result f(grid)
:param darken: Whether to take into account the modulus of the data to darken colors.
:param axes: The axes instance used for plotting.
:param linestylep: The line style of the phase curve.
:param linewidthp: The line width of the phase curve.
:param color: The color of the phase curve.
"""
# Color mapping
rgb_colors = color_map(modulus, phase=phase, modulus=modulus, darken=darken)
# Put all the vertical line into a collection
segments = [array([[node, 0], [node, value]]) for node, value in zip(grid, modulus)]
line_segments = LineCollection(segments)
# Set some properties of the lines
rgb_colors = line_segments.to_rgba(rgb_colors)
line_segments.set_color(rgb_colors[0])
line_segments.set_linestyle(linestylep)
line_segments.set_linewidth(linewidthp)
# Plot to the given axis instance or retrieve the current one
if axes is None:
axes = gca()
# Plot the phase
axes.add_collection(line_segments)
# Plot the modulus
axes.plot(grid, modulus, color=color, **kwargs)
def update_plot(self):
if len(self.variables.plot_data.shape) < 3:
self.pyplot_canvas.canvas.draw()
elif self.variables.plot_data is not None:
n_overplots = numpy.shape(self.variables.segments)[0]
animation_index = int(self.control_panel.scale.get())
for i in range(n_overplots):
self.variables.segments[
i, :, 1] = self.variables.plot_data[:, i, animation_index]
self.pyplot_canvas.axes.clear()
self.pyplot_canvas.axes.set_xlim(self.variables.xmin,
self.variables.xmax)
line_segments = LineCollection(
self.variables.segments,
self.pyplot_utils.linewidths,
linestyle=self.pyplot_utils.linestyle)
line_segments.set_color(self.pyplot_utils.rgb_array_full_palette)
if self.variables.set_y_margins_per_frame:
plot_data = self.variables.segments[:, :, 1]
y_range = plot_data.max() - plot_data.min()
self.variables.ymin = plot_data.min(
) - y_range * self.variables.y_margin
self.variables.ymax = plot_data.max(
) + y_range * self.variables.y_margin
self.pyplot_canvas.axes.set_ylim(self.variables.ymin,
self.variables.ymax)
self.pyplot_canvas.axes.add_collection(line_segments)
self.pyplot_canvas.canvas.draw()
else:
pass
def loadlines(self,
name,
curdir='beijingJson',
zorder=None,
linewidth=0.5,
color='k',
antialiased=1,
ax=None,
default_encoding='utf-8',
linestyle='-',
linesalpha=1):
# get current axes instance (if none specified).
filename = curdir + '/' + name + '.json'
coords = json.load(codecs.open(filename, 'r', 'utf-8'))
coords = self.projectcoords(coords)
ax = ax or self._check_ax()
# make LineCollections for each polygon.
lines = LineCollection(coords, antialiaseds=(1, ))
lines.set_color(color)
lines.set_linewidth(linewidth)
lines.set_linestyle(linestyle)
lines.set_alpha(linesalpha)
lines.set_label('_nolabel_')
if zorder is not None:
lines.set_zorder(zorder)
ax.add_collection(lines)
# set axes limits to fit map region.
self.set_axes_limits(ax=ax)
# clip boundaries to map limbs
lines, c = self._cliplimb(ax, lines)
self.__dict__[name] = coords
return lines
def segments(X, Y, color=(1, 0, 0, 0)):
N = X.shape[0]
z = np.zeros((N, 2, 2))
z[:, 0, :] = X
z[:, 1, :] = Y
lc = LineCollection(z)
lc.set_color(color)
plt.gca().add_collection(lc)
def segments(X,Y,color=(1,0,0,0)):
N = X.shape[0]
z = np.zeros((N,2,2));
z[:,0,:] = X
z[:,1,:] = Y
lc = LineCollection(z)
lc.set_color(color)
plt.gca().add_collection(lc)
def draw_graph(xy, edges, edgecolor='b'):
lcol = xy[edges]
lc = LineCollection(xy[edges])
lc.set_linewidth(0.1)
lc.set_color(edgecolor)
pl.gca().add_collection(lc)
pl.xlim(xy[:, 0].min(), xy[:, 0].max())
pl.ylim(xy[:, 1].min(), xy[:, 1].max())
def get_landcoastlines(basemap, color="0.0", linewidth=1):
landpolygons = np.where(np.array(basemap.coastpolygontypes) == 1)[0]
landsegs = []
for index in landpolygons:
landsegs.append(basemap.coastsegs[index])
landcoastlines = LineCollection(landsegs, antialiaseds=(1, ))
landcoastlines.set_color(color)
landcoastlines.set_linewidth(linewidth)
return landcoastlines
def plotgraph(xy, edges, edgecolor='b'):
lcol = xy[edges]
lc = LineCollection(xy[edges])
lc.set_linewidth(0.1)
lc.set_color(edgecolor)
pl.gca().add_collection(lc)
#pl.plot(xy[:,0], xy[:,1], 'ro')
pl.xlim(xy[:, 0].min(), xy[:, 0].max())
pl.ylim(xy[:, 1].min(), xy[:, 1].max())
pl.show()
def plotgraph(xy,edges,edgecolor='b'):
lcol = xy[edges]
lc = LineCollection(xy[edges])
lc.set_linewidth(0.1)
lc.set_color(edgecolor)
pl.gca().add_collection(lc)
#pl.plot(xy[:,0], xy[:,1], 'ro')
pl.xlim(xy[:,0].min(), xy[:,0].max())
pl.ylim(xy[:,1].min(), xy[:,1].max())
pl.show()
def plot(self,
show_minima=False,
show_trees=False,
linewidth=0.5,
axes=None):
"""draw the disconnectivity graph using matplotlib
don't forget to call calculate() first
also, you must call pyplot.show() to actually see the plot
"""
from matplotlib.collections import LineCollection
import matplotlib.pyplot as plt
self.line_segments, self.line_colours = self._get_line_segments(
self.tree_graph, eoffset=self.eoffset)
# get the axes object
if axes is not None:
ax = axes
else:
fig = plt.figure(figsize=(6, 7))
fig.set_facecolor('white')
ax = fig.add_subplot(111, adjustable='box')
#set up how the figure should look
ax.tick_params(axis='y', direction='out')
ax.yaxis.tick_left()
ax.spines['left'].set_color('black')
ax.spines['left'].set_linewidth(0.5)
ax.spines['top'].set_color('none')
ax.spines['bottom'].set_color('none')
ax.spines['right'].set_color('none')
# plt.box(on=True)
#draw the minima as points
if show_minima:
xpos, energies = self.get_minima_layout()
ax.plot(xpos, energies, 'o')
# draw the line segments
# use LineCollection because it's much faster than drawing the lines individually
linecollection = LineCollection([[(x[0], y[0]), (x[1], y[1])]
for x, y in self.line_segments])
linecollection.set_linewidth(linewidth)
linecollection.set_color(self.line_colours)
ax.add_collection(linecollection)
# scale the axes appropriately
ax.relim()
ax.autoscale_view(scalex=True, scaley=True, tight=None)
ax.set_ylim(top=self.Emax)
#remove xtics
ax.set_xticks([])
def plot_profiles(
self,
field="topographic__elevation",
xlabel="Distance Along Profile",
ylabel="Plotted Quantity",
title="Extracted Profiles",
color=None,
):
"""Plot distance-upstream vs at at-node or size (nnodes,) quantity.
Parameters
----------
field : field name or nnode array
Array of the at-node-field to plot against distance upstream.
Default value is the at-node field 'topographic__elevation'.
xlabel : str, optional
X-axis label, default is "Distance Along Profile".
ylabel : str, optional
Y-axis label, default value is "Plotted Quantity".
title : str, optional
Plot title, default value is "Extracted Profiles".
color : RGBA tuple or color string
Color to use in order to plot all profiles the same color. Default
is None, and the colors assigned to each profile are used.
"""
quantity = return_array_at_node(self._grid, field)
# create segments the way that line collection likes them.
segments = []
qmin = []
qmax = []
for idx, nodes in enumerate(self._nodes):
segments.append(
list(zip(self._distance_along_profile[idx], quantity[nodes])))
qmin.append(min(quantity[nodes]))
qmax.append(max(quantity[nodes]))
# We need to set the plot limits.
ax = plt.gca()
ax.set_xlim(
_recursive_min(self._distance_along_profile),
_recursive_max(self._distance_along_profile),
)
ax.set_ylim(min(qmin), max(qmax))
line_segments = LineCollection(segments)
colors = color or self._colors
line_segments.set_color(colors)
ax.add_collection(line_segments)
ax.set_xlabel(xlabel)
ax.set_ylabel(ylabel)
ax.set_title(title)
def plot(self, show_vor_points=True):
if show_vor_points:
self.plot_vor_points()
# plot the finite edges:
# build up the list of lines:
all_lines = self.nodes[self.edges]
coll = LineCollection(all_lines)
coll.set_color('m')
ax = plt.gca()
ax.add_collection(coll)
plt.draw()
def plot_2D_cells(cells, axes):
verts = np.array([cell.cube_map for cell in cells if cell.dim == 0]) / 2
edges = np.array([edge_vertices(cell) for cell in cells if cell.dim == 1])
faces = np.array([face_vertices(cell) for cell in cells if cell.dim == 2])
if verts.shape[0]:
axes.scatter(verts[:, 1], verts[:, 0], marker='s')
edges_coll = LineCollection(edges)
edges_coll.set_color('green')
edges_coll.set_linewidth(2)
faces_coll = PolyCollection(faces, )
faces_coll.set_color('pink')
axes.add_collection(edges_coll)
axes.add_collection(faces_coll)
def plot(self, show_minima=False, linewidth=0.5, axes=None):
"""draw the disconnectivity graph using matplotlib
don't forget to call calculate() first
also, you must call pyplot.show() to actually see the plot
"""
import matplotlib as mpl
from matplotlib.collections import LineCollection
import matplotlib.pyplot as plt
self.line_segments = self._get_line_segments(self.tree_graph, eoffset=self.eoffset)
#set up how the figure should look
if axes is not None:
ax = axes
else:
fig = plt.figure(figsize=(6,7))
fig.set_facecolor('white')
ax = fig.add_subplot(111, adjustable='box')
ax.tick_params(axis='y', direction='out')
ax.yaxis.tick_left()
ax.spines['left'].set_color('black')
ax.spines['left'].set_linewidth(0.5)
ax.spines['top'].set_color('none')
ax.spines['bottom'].set_color('none')
ax.spines['right'].set_color('none')
# plt.box(on=True)
#draw the minima as points
if show_minima:
leaves = self.tree_graph.get_leaves()
energies = [self._getEnergy(leaf.data["minimum"]) for leaf in leaves]
xpos = [leaf.data["x"] for leaf in leaves]
ax.plot(xpos, energies, 'o')
# draw the line segments
# use LineCollection because it's much faster than drawing the lines individually
linecollection = LineCollection([ [(x[0],y[0]), (x[1],y[1])] for x,y in self.line_segments])
linecollection.set_linewidth(linewidth)
linecollection.set_color("k")
ax.add_collection(linecollection)
# scale the axes appropriately
ax.relim()
ax.autoscale_view(scalex=True, scaley=True, tight=None)
#remove xtics
ax.set_xticks([])
def save_spl_curves(path: str, name: str, img: np.array, roi, spl, curves):
"""Takes a path string, a name, two arrays, a roi, and splines, and saves
the plotted array with splines superimposed.
Args:
path (str): The path to save the image to.
name (str): The filename.
img (np.array): The image.
vel (np.array): The velocity.
roi: A roi instance.
spl: Fitted spolines.
Returns:
"""
if not os.path.exists(path):
os.makedirs(path)
# Plot image.
fig, ax = plt.subplots(figsize=(10, 5))
plt.imshow(img, cmap=cm.gray)
# ax.set_title('Splines and characteristics.')
# Plot splines.
for v in roi:
# Plot roi.
y = roi[v]['y']
points = np.array([spl[v](y), y]).T.reshape(-1, 1, 2)
segments = np.concatenate([points[:-1], points[1:]], axis=1)
lc = LineCollection(segments)
lc.set_linewidth(2)
lc.set_color('C3')
plt.gca().add_collection(lc)
# Plot characteristics.
y = np.arange(y[0], y[-1] + 1, 1)
c = curves[v]
points = np.array([c, y]).T.reshape(-1, 1, 2)
segments = np.concatenate([points[:-1], points[1:]], axis=1)
lc = LineCollection(segments)
lc.set_linewidth(2)
lc.set_color('C0')
plt.gca().add_collection(lc)
fig.tight_layout()
fig.savefig(os.path.join(path, '{0}-splines-curves.png'.format(name)),
dpi=dpi,
bbox_inches='tight')
plt.close(fig)
def plot_cubical_2D_cell_complex(K):
fig, axes = configure_2D_plot(K)
verts = np.array([cell.cube_map for cell in K(0)]) / 2
edges = np.array([edge_vertices(cell) for cell in K(1)])
faces = np.array([face_vertices(cell) for cell in K(2)])
axes.scatter(verts[:, 1], verts[:, 0], alpha=0.5)
edges_coll = LineCollection(edges)
edges_coll.set_color('green')
edges_coll.set_alpha(0.5)
faces_coll = PolyCollection(faces, )
faces_coll.set_color('pink')
axes.add_collection(edges_coll)
axes.add_collection(faces_coll)
return fig, axes
def plotcf(grid,
phase,
modulus,
darken=None,
axes=None,
linestylep="solid",
linewidthp=1,
color="k",
**kwargs):
r"""Plot the modulus of a complex valued function
:math:`f:\mathbb{R} \rightarrow \mathbb{C}`
together with its phase in a color coded fashion.
:param grid: The grid nodes of the real domain R
:param phase: The phase of the complex domain result f(grid)
:param modulus: The modulus of the complex domain result f(grid)
:param darken: Whether to take into account the modulus of the data to darken colors.
:param axes: The axes instance used for plotting.
:param linestylep: The line style of the phase curve.
:param linewidthp: The line width of the phase curve.
:param color: The color of the phase curve.
"""
# Color mapping
rgb_colors = color_map(modulus,
phase=phase,
modulus=modulus,
darken=darken)
# Put all the vertical line into a collection
segments = [
array([[node, 0], [node, value]])
for node, value in zip(grid, modulus)
]
line_segments = LineCollection(segments)
# Set some properties of the lines
rgb_colors = line_segments.to_rgba(rgb_colors)
line_segments.set_color(rgb_colors[0])
line_segments.set_linestyle(linestylep)
line_segments.set_linewidth(linewidthp)
# Plot to the given axis instance or retrieve the current one
if axes is None:
axes = gca()
# Plot the phase
axes.add_collection(line_segments)
# Plot the modulus
axes.plot(grid, modulus, color=color, **kwargs)
def segments(self, points, color='black', **kwargs):
'plot line'
segments = numpy.concatenate([numpy.array([xy[:-1], xy[1:]]).swapaxes(0,1) for xy in points], axis=0)
from matplotlib.collections import LineCollection
lc = LineCollection(segments, **kwargs)
ax = self.gca()
ax.add_collection(lc)
if isinstance(color, str):
lc.set_color(color)
else:
array = numpy.concatenate([.5 * (v[:-1] + v[1:]) for v in color], axis=0)
lc.set_array(array)
self.sci(lc)
return lc
def generate_boundary_artist(vertices, color):
if DIM == 2:
artist = LineCollection(vertices)
artist.set_color(color)
artist.set_linewidth(2.5)
elif DIM == 3:
artist = Poly3DCollection(vertices, linewidths=1)
# transparency alpha must be set BEFORE face/edge color
artist.set_alpha(0.5)
artist.set_facecolor(color)
artist.set_edgecolor('k')
else:
raise ValueError(
"%d dimensions needs special attention for plotting." % int(DIM))
return artist
def _add_plot(fig, ax, plot_data, color_data, pkeys, lw=1, cmap='_auto',
alpha=1.0):
colors = color_data.color
if cmap == '_auto':
cmap = None
if color_data.is_categorical:
colors = np.take(COLOR_CYCLE, colors, mode='wrap')
if plot_data.scatter:
data, = plot_data.trajs
artist = ax.scatter(*data.T, marker='o', c=colors, edgecolor='none',
s=lw*20, cmap=cmap, alpha=alpha, picker=5)
else:
# trajectory plot
if hasattr(colors, 'dtype') and np.issubdtype(colors.dtype, np.number):
# delete lines with NaN colors
mask = np.isfinite(colors)
if mask.all():
trajs = plot_data.trajs
else:
trajs = [t for i,t in enumerate(plot_data.trajs) if mask[i]]
colors = colors[mask]
artist = LineCollection(trajs, linewidths=lw, cmap=cmap)
artist.set_array(colors)
else:
artist = LineCollection(plot_data.trajs, linewidths=lw, cmap=cmap)
artist.set_color(colors)
artist.set_alpha(alpha)
artist.set_picker(True)
artist.set_pickradius(5)
ax.add_collection(artist, autolim=True)
ax.autoscale_view()
# Force ymin -> 0
ax.set_ylim((0, ax.get_ylim()[1]))
def on_pick(event):
if event.artist is not artist:
return
label = pkeys[event.ind[0]]
ax.set_title(label)
fig.canvas.draw_idle()
# XXX: hack, make this more official
if hasattr(fig, '_superman_cb'):
fig.canvas.mpl_disconnect(fig._superman_cb[0])
cb_id = fig.canvas.mpl_connect('pick_event', on_pick)
fig._superman_cb = (cb_id, on_pick)
return artist
def plot_profiles_in_map_view(self,
field="topographic__elevation",
endpoints_only=False,
color=None,
**kwds):
"""Plot profile locations in map view.
Parameters
----------
field : field name or nnode array
Array of the at-node-field to plot as the 2D map values.
Default value is the at-node field 'topographic__elevation'.
endpoints_only : boolean
Boolean where False (default) indicates every node along the
profile is plotted, or True indicating only segment endpoints are
plotted.
color : RGBA tuple or color string
Color to use in order to plot all profiles the same color. Default
is None, and the colors assigned to each profile are used.
**kwds : dictionary
Keyword arguments to pass to imshow_grid.
"""
# make imshow_grid background
imshow_grid(self._grid, field, **kwds)
ax = plt.gca()
# create segments the way that line collection likes them.
segments = []
for idx, nodes in enumerate(self._nodes):
if endpoints_only:
select_nodes = [nodes[0], nodes[-1]]
segments.append(
list(
zip(
self._grid.x_of_node[select_nodes],
self._grid.y_of_node[select_nodes],
)))
else:
segments.append(
list(
zip(self._grid.x_of_node[nodes],
self._grid.y_of_node[nodes])))
line_segments = LineCollection(segments)
colors = color or self._colors
line_segments.set_color(colors)
ax.add_collection(line_segments)
def plot(self, plot, col):
# Set the scale of the plot
if self.log_x:
plot.xscale('log')
if self.log_y:
plot.yscale('log')
# Process the values
values = []
for x in self.get_x_data_gen().get_values():
for y in self.get_y_data_gen().get_values():
values.append(zip(x,y))
lines = LineCollection(values)
lines.set_color(col)
lines.set_label(str(self.get_name()))
# Plot the values
plot.add_collection(lines)
def drawstates(self,ax,linewidth=0.5,color='k',antialiased=1):
"""
Draw state boundaries in Americas.
ax - current axis instance.
linewidth - state boundary line width (default 0.5)
color - state boundary line color (default black)
antialiased - antialiasing switch for state boundaries (default True).
"""
coastlines = LineCollection(self.statesegs,antialiaseds=(antialiased,))
try:
coastlines.set_color(color)
except: # this was a typo that existed in matplotlib-0.71 and earlier
coastlines.color(color)
coastlines.set_linewidth(linewidth)
ax.add_collection(coastlines)
def add_lines(self, levels, colors, linewidths):
'''
Draw lines on the colorbar.
'''
N = len(levels)
y = self._locate(levels)
x = nx.array([0.0, 1.0])
X, Y = meshgrid(x, y)
if self.orientation == 'vertical':
xy = [zip(X[i], Y[i]) for i in range(N)]
else:
xy = [zip(Y[i], X[i]) for i in range(N)]
col = LineCollection(xy, linewidths=linewidths)
self.lines = col
col.set_color(colors)
self.ax.add_collection(col)
def generate_boundary_artist(vertices, color):
ndim = len(next(iter(vertices[0])))
vertices = tuple(map(tuple, vertices))
if ndim == 2:
artist = LineCollection(vertices)
artist.set_color(color)
artist.set_linewidth(2.5)
elif ndim == 3:
artist = Poly3DCollection(vertices, linewidth=1)
# transparency alpha must be set BEFORE face/edge color
artist.set_alpha(0.5)
artist.set_facecolor(color)
artist.set_edgecolor('k')
else:
raise ValueError("{:d} dimensions needs special attention for plotting".format(ndim))
return artist
def add_lines(self, levels, colors, linewidths):
"""
Draw lines on the colorbar.
"""
N = len(levels)
y = self._locate(levels)
x = nx.array([0.0, 1.0])
X, Y = meshgrid(x, y)
if self.orientation == "vertical":
xy = [zip(X[i], Y[i]) for i in range(N)]
else:
xy = [zip(Y[i], X[i]) for i in range(N)]
col = LineCollection(xy, linewidths=linewidths)
self.lines = col
col.set_color(colors)
self.ax.add_collection(col)
def drawcountries(self,linewidth=0.5,color='k',antialiased=1):
"""
Draw country boundaries.
linewidth - country boundary line width (default 0.5)
color - country boundary line color (default black)
antialiased - antialiasing switch for country boundaries (default True).
"""
# get current axes instance.
ax = pylab.gca()
coastlines = LineCollection(self.cntrysegs,antialiaseds=(antialiased,))
try:
coastlines.set_color(color)
except: # this was a typo that existed in matplotlib-0.71 and earlier
coastlines.color(color)
coastlines.set_linewidth(linewidth)
ax.add_collection(coastlines)
def drawstates(self, ax, linewidth=0.5, color='k', antialiased=1):
"""
Draw state boundaries in Americas.
ax - current axis instance.
linewidth - state boundary line width (default 0.5)
color - state boundary line color (default black)
antialiased - antialiasing switch for state boundaries (default True).
"""
coastlines = LineCollection(self.statesegs,
antialiaseds=(antialiased, ))
try:
coastlines.set_color(color)
except: # this was a typo that existed in matplotlib-0.71 and earlier
coastlines.color(color)
coastlines.set_linewidth(linewidth)
ax.add_collection(coastlines)
def plot_trajectory_ellipse(frame, varx="attr_VARX", vary="attr_VARY", covxy="attr_COVXY", opacity_factor=1):
"""
Draw the trajectory and uncertainty ellipses around teach point.
1) Scatter of points
2) Trajectory lines
3) Ellipses
:param frame: Trajectory
:param opacity_factor: all opacity values are multiplied by this. Useful when used to plot multiple Trajectories in
an overlay plot.
:return: axis
"""
ellipses = []
segments = []
start_point = None
for i, pnt in frame.iterrows():
# The ellipse
U, s, V = np.linalg.svd(np.array([[pnt[varx], pnt[covxy]],
[pnt[covxy], pnt[vary]]]), full_matrices=True)
w, h = s**.5
theta = np.arctan(V[1][0]/V[0][0]) # == np.arccos(-V[0][0])
ellipse = {"xy":pnt[list(frame.geo_cols)].values, "width":w, "height":h, "angle":theta}
ellipses.append(Ellipse(**ellipse))
# The line segment
x, y = pnt[list(frame.geo_cols)][:2]
if start_point:
segments.append([start_point, (x, y)])
start_point = (x, y)
ax = plt.gca()
ellipses = PatchCollection(ellipses)
ellipses.set_facecolor('none')
ellipses.set_color("green")
ellipses.set_linewidth(2)
ellipses.set_alpha(.4*opacity_factor)
ax.add_collection(ellipses)
frame.plot(kind="scatter", x=frame.geo_cols[0], y=frame.geo_cols[1], marker=".", ax=plt.gca(), alpha=opacity_factor)
lines = LineCollection(segments)
lines.set_color("gray")
lines.set_linewidth(1)
lines.set_alpha(.2*opacity_factor)
ax.add_collection(lines)
return ax
def drawcoastlines(self,linewidth=1.,color='k',antialiased=1):
"""
Draw coastlines.
linewidth - coastline width (default 1.)
color - coastline color (default black)
antialiased - antialiasing switch for coastlines (default True).
"""
# get current axes instance.
ax = pylab.gca()
coastlines = LineCollection(self.coastsegs,antialiaseds=(antialiased,))
try:
coastlines.set_color(color)
except: # this was a typo that existed in matplotlib-0.71 and earlier
coastlines.color(color)
coastlines.set_linewidth(linewidth)
ax.add_collection(coastlines)
# set axes limits to fit map region.
self.set_axes_limits()
def plotExpectationContours(self, projection = [0,0], showDU=False, showMU=False, plot=None, alpha=1): if plot is None: plot = pl.figure().add_subplot(1,1,1) self.setLimits(xprojection=projection) self.labelAxes(plot) mpl.rcParams['lines.linewidth']=1 minx = min(self.OD.indAttr())-projection[0] maxx = max(self.OD.indAttr())+projection[1] x = np.array([np.linspace(minx, maxx, self.xres)]).T y_pred = self.ED.getExpectationsAt(x,False) DUvals=np.zeros(len(x)) MUvals=np.zeros(len(x)) if showDU: DUvals = self.OD.distanceUncertainty(x) if showMU: MUvals = self.ED.misclassUncertainty(x) scaling = 1-np.minimum(np.ones(len(x)),DUvals+MUvals) maxLW = 3 minLW = 0.25 for i,b in enumerate(self.OD.bins): alpha=1 #alpha = 1-(abs(i-len(self.OD.bins)/2.0)/float(len(self.OD.bins)/2.0)) # Weight the colour of the contour to the distance from the median points = np.array([x[:,0], y_pred[b]]).T.reshape(-1, 1, 2) segments = np.concatenate([points[:-1], points[1:]], axis=1) # create a (r,g,b,a) color description for each line segment cmap = [] for a in segments: # the x-value for this segment is: x0 = a.mean(0)[0] # so it has a scaling value of: s0 = np.interp(x0,x[:,0],scaling) cmap.append([1-s0,0,s0,alpha]) # Create the line collection object, and set the color parameters. distFromMedian = 2 * abs(b - 0.5) lw = (1 - distFromMedian) * (maxLW-minLW)+minLW #if b== 0.5: # lw = 3 lc = LineCollection(segments, linewidths=lw) lc.set_color(cmap) plot.add_collection(lc) return plot
def stemcf(grid, phase, modulus, darken=False, axes=None, linestylep="solid", linewidthp=2, color=None, markerp="o", **kwargs):
r"""
Stemplot the modulus of a complex valued function :math:`f:I \rightarrow C` together with its phase in a color coded fashion.
:param grid: The grid nodes of the real domain R
:param phase: The phase of the complex domain result f(grid)
:param modulus: The modulus of the complex domain result f(grid)
:param darken: Whether to take into account the modulus of the data to darken colors.
:param axes: The axes instance used for plotting.
:param linestylep: The line style of the phase curve.
:param linewidthp: The line width of the phase curve.
:param color: The color of the stemmed markers.
:param markerp: The shape of the stemmed markers.
.. note:: Additional keyword arguments are passe to the plot function.
"""
# Color mapping
rgb_colors = color_map(grid, phase=phase, modulus=modulus, darken=darken)
# Put all the vertical line into a collection
segments = [ array([[node,0], [node,value]]) for node, value in zip(grid, modulus) ]
line_segments = LineCollection(segments)
# Set some properties of the lines
rgb_colors = line_segments.to_rgba(rgb_colors)
line_segments.set_color(rgb_colors[0])
line_segments.set_linestyle(linestylep)
line_segments.set_linewidth(linewidthp)
# Plot to the given axis instance or retrieve the current one
if axes is None:
axes = gca()
# Plot the phase
axes.add_collection(line_segments)
# Plot the modulus
if color is None:
# Scatter has a problem with complex data type, make sure values are purely real
axes.scatter(grid, real(modulus), c=rgb_colors[0], **kwargs)
else:
axes.plot(grid, modulus, linestyle="", marker=markerp, color=color, **kwargs)
# Plot the ground line
axes.plot(grid, zeros(grid.shape), linestyle=linestylep, color="k", **kwargs)
def drawcountries(self,linewidth=0.5,color='k',antialiased=1):
"""
Draw country boundaries.
linewidth - country boundary line width (default 0.5)
color - country boundary line color (default black)
antialiased - antialiasing switch for country boundaries (default True).
"""
# get current axes instance.
ax = pylab.gca()
coastlines = LineCollection(self.cntrysegs,antialiaseds=(antialiased,))
try:
coastlines.set_color(color)
except: # this was a typo that existed in matplotlib-0.71 and earlier
coastlines.color(color)
coastlines.set_linewidth(linewidth)
ax.add_collection(coastlines)
# set axes limits to fit map region.
self.set_axes_limits()
def plot_fracdos():
K1=1.4
K2=1.0
nsite=100
target_block=(0,0)
dmu_mag=0.01
fnames=['fracdos_W1%s_W2%s_U%s_N%s_dmu%s_%s.dat'%(K1,K2,0.,nsite,dmu,target_block) for dmu in [dmu_mag,-dmu_mag]]
pls=[loadtxt(fname) for fname in fnames]
pls=array(pls)-0.5
nsite=pls.shape[-1]
pls_left=pls[...,:nsite/2]
pls_right=pls[...,nsite/2:]
print 'occupation in left block -> %s, right block -> %s.'%(sum(pls_left,axis=(-1,-2)),sum(pls_right,axis=(-1,-2)))
ion()
fig=figure(figsize=(7,5))
lw=2
lc='r'
axs=[]
site_loc=append(arange(20),arange(25,45))
sites=append(arange(20),arange(nsite-20,nsite))
for n in xrange(len(pls)):
pln=pls[n].sum(axis=0)
ax=subplot(11+n+100*len(pls),sharex=axs[0] if n==1 else None)
text(0.02,0.9,'(a)' if n==0 else '(b)',transform=ax.transAxes)
color='k'
lc=LineCollection([[(posi,0),(posi,pln[sitei].item())] for posi,sitei in zip(site_loc,sites)])
lc.set_linewidth(lw)
lc.set_color(color)
#lc.set_linestyle('--' if s==1 else '-')
ax.add_collection(lc)
ax.autoscale()
ax.margins(0.1)
ylabel(r'$\rho-\bar{\rho}$',fontsize=LABELSIZE)
ax.set_xticks(list(site_loc[:20:5])+[23]+list(site_loc[19::5]))
ax.set_xticklabels(list(sites[:20:5]+1)+[r'$\bf{\ldots}$']+list(sites[19::5]))
yticks([-0.5,-0.25,0,0.25,0.5])
xlabel(r'$N$',fontsize=LABELSIZE)
subplots_adjust(hspace=0.05)
pdb.set_trace()
savefig('fracdos.eps')
savefig('fracdos.png')
def create_linecollection():
'''
According to the LineCollection tutorial: "We need to set the plot limits, they will not autoscale"
- The autoscale() method works!
- It is NOT implicitly invoked
- LineCollection objects don't have a __len__() nor are they iterable
'''
segments = [
[(0, 0), (5, 5)], # line_0 # 2 points
[(1, 1.1), (6, 6)], # line_1 # 2 points
[(2, 2), (4, 0), (10, 1)] # line_2: 3 points
]
lc = LineCollection(segments)
lc.set_color(('r', 'g', 'b'))
fig, ax = plt.subplots()
ax.add_collection(lc)
ax.autoscale()
#ax.set_xlim(0, 10)
#ax.set_ylim(0, 10)
plt.show()
def stemcf(grid, phase, modulus, darken=None, axes=None, linestylep="solid", linewidthp=2, color=None, markerp="o", **kwargs):
r"""Stemplot the modulus of a complex valued function :math:`f:I -> \mathbb{C}` together with its phase in a color coded fashion.
Additional keyword arguments are passed to the plot function.
:param grid: The grid nodes of the real domain grid :math:`\Gamma`
:param phase: The phase of the complex domain result :math:`f(\Gamma)`
:param modulus: The modulus of the complex domain result :math:`f(\Gamma)`
:param darken: Whether to take into account the modulus of the data to darken colors.
:param axes: The axes instance used for plotting.
:param linestylep: The line style of the phase curve.
:param linewidthp: The line width of the phase curve.
:param color: The color of the stemmed markers.
:param markerp: The shape of the stemmed markers.
"""
# Color mapping
rgb_colors = color_map(grid, phase=phase, modulus=modulus, darken=darken)
# Put all the vertical line into a collection
segments = [array([[node, 0], [node, value]]) for node, value in zip(grid, modulus)]
line_segments = LineCollection(segments)
# Set some properties of the lines
rgb_colors = line_segments.to_rgba(rgb_colors)
line_segments.set_color(rgb_colors[0])
line_segments.set_linestyle(linestylep)
line_segments.set_linewidth(linewidthp)
# Plot to the given axis instance or retrieve the current one
if axes is None:
axes = gca()
# Plot the phase
axes.add_collection(line_segments)
# Plot the modulus
if color is None:
# Scatter has a problem with complex data type, make sure values are purely real
axes.scatter(grid, real(modulus), c=rgb_colors[0], **kwargs)
else:
axes.plot(grid, modulus, linestyle="", marker=markerp, color=color, **kwargs)
# Plot the ground line
axes.plot(grid, zeros(grid.shape), linestyle=linestylep, color="k", **kwargs)
def plot_sparse_trajectory(trajectory, r=50, opacity_factor=1, plot_text=True,
num_col="segment_sparcify_n", min_static=100):
"""
Plots a sparsified trajectory as circles with the number of points they represent as a number inside.
:param trajectory: Trajectory object
:param r: the radius of circles
:param num_col: where to find the number to put in the circles
:param min_static: minimum count to change color of circle
:param plot_text: put the text with num of points in the circle?
:return: ax
"""
ax = plt.gca()
trajectory.plot(kind="scatter", x=trajectory.geo_cols[0], y=trajectory.geo_cols[1], marker=".",
ax=plt.gca(), alpha=0.0*opacity_factor)
circles = []
segments = []
start_point = None
for i, pnt in trajectory.iterrows():
circles.append(Circle(pnt[list(trajectory.geo_cols)].values, radius=r))
if plot_text:
plt.text(*pnt[list(trajectory.geo_cols)], s=str(int(pnt[num_col])), fontsize=12)
x, y = pnt[list(trajectory.geo_cols)][:2]
if start_point:
segments.append([start_point, (x, y)])
start_point = (x, y)
circles = PatchCollection(circles)
circles.set_facecolor(['none' if cnt < min_static else 'red' for cnt in trajectory[num_col].values])
circles.set_alpha(.5*opacity_factor)
ax.add_collection(circles)
lines = LineCollection(segments)
lines.set_color("gray")
lines.set_alpha(.2*opacity_factor)
ax.add_collection(lines)
return ax
class LineCollection(object):
def __init__(self, ax):
self._ax = ax
self._lc = None
@property
def artists(self):
return [self._lc]
def draw(self, x, y, **kwargs):
xy = np.stack([x, y], axis=1)
xy = xy.reshape(-1, 1, 2)
segments = np.hstack([xy[:-1], xy[1:]])
if self._lc is None:
self._lc = PltLineCollection(segments)
self._ax.add_collection(self._lc)
else:
self._lc.set_segments(segments)
if 'color' in kwargs:
self._lc.set_color(kwargs['color'])
def show_mf_wave(**kwargs):
K1=1.4
K2=1.0
U=0.0
nsite=100
dmu=0.01
lw=2
lc='r'
mjfile='mf_W1%s_W2%s_U%s_N%s_dmu%s.npy'%(K1,K2,U,nsite,dmu)
pls=load(mjfile)
ampl=(pls[:2]*pls[:2].conj()).real
nsite=pls.shape[1]
ion()
fig=figure(figsize=(7,4))
for n in xrange(2):
pln=ampl[n]
ax=subplot(121+n)
lc=LineCollection([[(i+1,0),(i+1,pln[i].item())] for i in xrange(nsite)])
lc.set_linewidth(lw)
lc.set_color('k')
ax.add_collection(lc)
ax.autoscale()
ax.margins(0.1)
if n==0:
text(0.02,0.9,'(a)',transform=ax.transAxes,color='k')
xlim(0,22)
xticks(arange(1,22,5))
ylabel(r'$|\phi_j|^2$',fontsize=LABELSIZE)
else:
text(0.02,0.9,'(b)',transform=ax.transAxes,color='k')
xlim(79,101)
yticks([])
ylim(0,0.2)
xlabel('$j$',fontsize=LABELSIZE)
tight_layout(w_pad=0.5)
pdb.set_trace()
savefig('mf.eps')
savefig('mf.png')
def changeVecteur(self, ech=1., col=None):
""" modifie les valeurs de vecteurs existants"""
self.drawVecteur(False)
if type(ech) == type((3, 4)):
if len(ech) >= 1: ech = ech[0]
# previous object
obj = self.getObjFromType('vecteur')
if obj == None: return
#change coordinates
dep, arr_old, ech_old = obj.getData()
arr = dep + (arr_old - dep) * ech / ech_old
# new object
lc1 = LineCollection(zip(dep, arr))
lc1.set_transform(self.transform)
if col == None: col = wx.Color(0, 0, 255)
a = col.Get()
col = (a[0] / 255, a[1] / 255, a[2] / 255)
lc1.set_color(col)
obj = GraphicObject('vecteur', lc1, False, None)
obj.setData([dep, arr, ech])
self.addGraphicObject(obj)
self.cnv.collections[0] = lc1
self.redraw()
class SURFDemo(ImageProcessDemo):
TITLE = "SURF Demo"
DEFAULT_IMAGE = "lena.jpg"
SETTINGS = ["m_perspective", "hessian_threshold", "n_octaves"]
m_perspective = Array(np.float, (3, 3))
m_perspective2 = Array(np.float, (3, 3))
hessian_threshold = Int(2000)
n_octaves = Int(2)
poly = Instance(PolygonWidget)
def control_panel(self):
return VGroup(
Item("m_perspective", label=u"变换矩阵", editor=ArrayEditor(format_str="%g")),
Item("m_perspective2", label=u"变换矩阵", editor=ArrayEditor(format_str="%g")),
Item("hessian_threshold", label=u"hessianThreshold"),
Item("n_octaves", label=u"nOctaves")
)
def __init__(self, **kwargs):
super(SURFDemo, self).__init__(**kwargs)
self.poly = None
self.init_points = None
self.lines = LineCollection([], linewidths=1, alpha=0.6, color="red")
self.axe.add_collection(self.lines)
self.connect_dirty("poly.changed,hessian_threshold,n_octaves")
def init_poly(self):
if self.poly is None:
return
h, w, _ = self.img_color.shape
self.init_points = np.array([(w, 0), (2*w, 0), (2*w, h), (w, h)], np.float32)
self.poly.set_points(self.init_points)
self.poly.update()
def init_draw(self):
style = {"marker": "o"}
self.poly = PolygonWidget(axe=self.axe, points=np.zeros((3, 2)), style=style)
self.init_poly()
@on_trait_change("hessian_threshold, n_octaves")
def calc_surf1(self):
self.surf = cv2.SURF(self.hessian_threshold, self.n_octaves)
self.key_points1, self.features1 = self.surf.detectAndCompute(self.img_gray, None)
self.key_positions1 = np.array([kp.pt for kp in self.key_points1])
def _img_changed(self):
self.img_gray = cv2.cvtColor(self.img, cv2.COLOR_BGR2GRAY)
self.img_color = cv2.cvtColor(self.img_gray, cv2.COLOR_GRAY2RGB)
self.img_show = np.concatenate([self.img_color, self.img_color], axis=1)
self.size = self.img_color.shape[1], self.img_color.shape[0]
self.calc_surf1()
FLANN_INDEX_KDTREE = 1
index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5)
search_params = dict(checks=100)
self.matcher = cv2.FlannBasedMatcher(index_params, search_params)
self.init_poly()
def settings_loaded(self):
src = self.init_points.copy()
w, h = self.size
src[:, 0] -= w
dst = cv2.perspectiveTransform(src[None, :, :], self.m_perspective)
dst = dst.squeeze()
dst[:, 0] += w
self.poly.set_points(dst)
self.poly.update()
def draw(self):
if self.poly is None:
return
w, h = self.size
src = self.init_points.copy()
dst = self.poly.points.copy().astype(np.float32)
src[:, 0] -= w
dst[:, 0] -= w
m = cv2.getPerspectiveTransform(src, dst)
self.m_perspective = m
img2 = cv2.warpPerspective(self.img_gray, m, self.size, borderValue=[255]*4)
self.img_show[:, w:, :] = img2[:, :, None]
key_points2, features2 = self.surf.detectAndCompute(img2, None)
key_positions2 = np.array([kp.pt for kp in key_points2])
match_list = self.matcher.knnMatch(self.features1, features2, k=1)
index1 = np.array([m[0].queryIdx for m in match_list])
index2 = np.array([m[0].trainIdx for m in match_list])
distances = np.array([m[0].distance for m in match_list])
n = min(50, len(distances))
best_index = np.argsort(distances)[:n]
matched_positions1 = self.key_positions1[index1[best_index]]
matched_positions2 = key_positions2[index2[best_index]]
self.m_perspective2, mask = cv2.findHomography(matched_positions1, matched_positions2, cv2.RANSAC)
lines = np.concatenate([matched_positions1, matched_positions2], axis=1)
lines[:, 2] += w
line_colors = COLORS[mask.ravel()]
self.lines.set_segments(lines.reshape(-1, 2, 2))
self.lines.set_color(line_colors)
self.draw_image(self.img_show)
class SpiroGraph(object):
'''
Spirograph drawer with matplotlib slider widgets to change parameters.
Parameters of line are:
R: The radius of the big circle
r: The radius of the small circle which rolls along the inside of the
bigger circle
p: distance from centre of smaller circle to point in the circle where
the pen hole is.
tmax: the angle through which the smaller circle is rotated to draw the
spirograph
tstep: how often matplotlib plots a point
a, b, c: parameters of the linewidth equation.
'''
# kwargs for each of the matplotlib sliders
slider_kwargs = (
{'label': 't_max', 'valmin': np.pi, 'valmax': 200 * np.pi,
'valinit': tmax0, 'valfmt': PiString()},
{'label': 't_step', 'valmin': 0.01,
'valmax': 10, 'valinit': tstep0},
{'label': 'R', 'valmin': 1, 'valmax': 200, 'valinit': R0},
{'label': 'r', 'valmin': 1, 'valmax': 200, 'valinit': r0},
{'label': 'p', 'valmin': 1, 'valmax': 200, 'valinit': p0},
{'label': 'colour', 'valmin': 0, 'valmax': 1, 'valinit': 1},
{'label': 'width_a', 'valmin': 0.5, 'valmax': 10, 'valinit': 1},
{'label': 'width_b', 'valmin': 0, 'valmax': 10, 'valinit': 0},
{'label': 'width_c', 'valmin': 0, 'valmax': 10, 'valinit': 0.5})
rbutton_kwargs = (
{'labels': ('black', 'white'), 'activecolor': 'white', 'active': 0},
{'labels': ('solid', 'variable'), 'activecolor': 'white', 'active': 0})
def __init__(self, colormap, figsize=(7, 10)):
self.colormap_name = colormap
self.variable_color = False
# Use ScalarMappable to map full colormap to range 0 - 1
self.colormap = ScalarMappable(cmap=colormap)
self.colormap.set_clim(0, 1)
# set up main axis onto which to draw spirograph
self.figsize = figsize
plt.rcParams['figure.figsize'] = figsize
self.fig, self.mainax = plt.subplots()
plt.subplots_adjust(bottom=0.3)
title = self.mainax.set_title('Spirograph Drawer!',
size=20,
color='white')
self.text = [title, ]
# set up slider axes
self.slider_axes = [plt.axes([0.25, x, 0.65, 0.015])
for x in np.arange(0.05, 0.275, 0.025)]
# same again for radio buttons
self.rbutton_axes = [plt.axes([0.025, x, 0.1, 0.15])
for x in np.arange(0.02, 0.302, 0.15)]
# use log scale for tstep slider
self.slider_axes[1].set_xscale('log')
# turn off frame, ticks and tick labels for all axes
for ax in chain(self.slider_axes, self.rbutton_axes, [self.mainax, ]):
ax.axis('off')
# use axes and kwargs to create list of sliders/rbuttons
self.sliders = [Slider(ax, **kwargs)
for ax, kwargs in zip(self.slider_axes,
self.slider_kwargs)]
self.rbuttons = [RadioButtons(ax, **kwargs)
for ax, kwargs in zip(self.rbutton_axes,
self.rbutton_kwargs)]
self.update_figcolors()
# set up initial line
self.t = np.arange(0, tmax0, tstep0)
x, y = spiro_linefunc(self.t, R0, r0, p0)
self.linecollection = LineCollection(
segments(x, y),
linewidths=spiro_linewidths(self.t, a0, b0, c0),
color=self.colormap.to_rgba(col0))
self.mainax.add_collection(self.linecollection)
# creates the plot and connects sliders to various update functions
self.run()
def update_figcolors(self, bgcolor='black'):
'''
function run by background color radiobutton. Sets all labels, text,
and sliders to foreground color, all axes to background color
'''
fgcolor = 'white' if bgcolor == 'black' else 'black'
self.fig.set_facecolor(bgcolor)
self.mainax.set_axis_bgcolor(bgcolor)
for ax in chain(self.slider_axes, self.rbutton_axes):
ax.set_axis_bgcolor(bgcolor)
# set fgcolor elements to black or white, mostly elements of sliders
for item in chain(map(attrgetter('label'), self.sliders),
map(attrgetter('valtext'), self.sliders),
map(attrgetter('poly'), self.sliders),
self.text,
*map(attrgetter('labels'), self.rbuttons)):
item.set_color(fgcolor)
self.update_radiobutton_colors()
plt.draw()
def update_linewidths(self, *args):
'''
function run by a, b and c parameter sliders. Sets width of each line
in linecollection according to sine function
'''
a, b, c = (s.val for s in self.sliders[6:])
self.linecollection.set_linewidths(spiro_linewidths(self.t, a, b, c))
plt.draw()
def update_linecolors(self, *args):
'''
function run by color slider and indirectly by variable/solid color
radiobutton. Updates colors of each line in linecollection using the
set colormap.
'''
# get current color value (a value between 1 and 0)
col_val = self.sliders[5].val
if not self.variable_color:
# if solid color, convert color value to rgb and set the color
self.linecollection.set_color(self.colormap.to_rgba(col_val))
else:
# create values between 0 and 1 for each line segment
colors = (self.t / max(self.t)) + col_val
# use color value to roll colors
colors[colors > 1] -= 1
self.linecollection.set_color(
[self.colormap.to_rgba(i) for i in colors])
plt.draw()
def update_lineverts(self, *args):
'''
function run by R, r, p, tmax and tstep sliders to update line vertices
'''
tmax, tstep, R, r, p = (s.val for s in self.sliders[:5])
self.t = np.arange(0, tmax, tstep)
x, y = spiro_linefunc(self.t, R, r, p)
self.linecollection.set_verts(segments(x, y))
# change axis limits to pad new line nicely
self.mainax.set(xlim=(min(x) - 5, max(x) + 5),
ylim=(min(y) - 5, max(y) + 5))
plt.draw()
def update_linecolor_setting(self, val):
'''
function run by solid/variable colour slider, alters variable_color
attribute then calls update_linecolors
'''
if val == 'variable':
self.variable_color = True
elif val == 'solid':
self.variable_color = False
# need to update radiobutton colors here.
self.update_radiobutton_colors()
self.update_linecolors()
def update_radiobutton_colors(self):
'''
makes radiobutton colors correct even on a changing axis background
'''
bgcolor = self.rbuttons[0].value_selected
fgcolor = 'white' if bgcolor == 'black' else 'black'
for i, b in enumerate(self.rbuttons):
# find out index of the active button
active_idx = self.rbutton_kwargs[i]['labels'].index(
b.value_selected)
# set button colors accordingly
b.circles[not active_idx].set_color(bgcolor)
b.circles[active_idx].set_color(fgcolor)
def run(self):
'''
set up slider functions
'''
verts_func = self.update_lineverts
colors_func = self.update_linecolors
widths_func = self.update_linewidths
# create iterable of slider funcs to zip with sliders
slider_update_funcs = chain(repeat(verts_func, 5),
[colors_func, ],
repeat(widths_func, 3))
# set slider on_changed functions
for s, f in zip(self.sliders, slider_update_funcs):
s.on_changed(f)
self.rbuttons[0].on_clicked(self.update_figcolors)
self.rbuttons[1].on_clicked(self.update_linecolor_setting)
plt.show()
# a "waterfall" plot or a "stagger" plot.
nverts = 60
ncurves = 20
offs = (0.1, 0.0)
rs = np.random.RandomState([12345678])
yy = np.linspace(0, 2*np.pi, nverts)
ym = np.amax(yy)
xx = (0.2 + (ym-yy)/ym)**2 * np.cos(yy-0.4) * 0.5
segs = []
for i in range(ncurves):
xxx = xx + 0.02*rs.randn(nverts)
curve = list(zip(xxx, yy*100))
segs.append(curve)
colors = [(1.0, 0.0, 0.0, 1.0), (0.0, 0.5, 0.0, 1.0), (0.0, 0.0, 1.0, 1.0), (0.0, 0.75, 0.75, 1.0),
(0.75, 0.75, 0, 1.0), (0.75, 0, 0.75, 1.0), (0.0, 0.0, 0.0, 1.0)]
col = LineCollection(segs, linewidth=5, offsets=offs)
ax = plt.axes()
ax.add_collection(col, autolim=True)
col.set_color(colors)
ax.set_title('Successive data offsets')
fig = plt.gcf()
pyplot.show_bokeh(plt.gcf(), filename="mpl_lc_offsets.html")
plotting.session().dumpjson(file="mpl_lc_offsets.json")
class ScatterLayerArtist(MatplotlibLayerArtist):
_layer_state_cls = ScatterLayerState
def __init__(self, axes, viewer_state, layer_state=None, layer=None):
super(ScatterLayerArtist, self).__init__(axes, viewer_state,
layer_state=layer_state, layer=layer)
# Watch for changes in the viewer state which would require the
# layers to be redrawn
self._viewer_state.add_global_callback(self._update_scatter)
self.state.add_global_callback(self._update_scatter)
# Scatter
self.scatter_artist = self.axes.scatter([], [])
self.plot_artist = self.axes.plot([], [], 'o', mec='none')[0]
self.errorbar_artist = self.axes.errorbar([], [], fmt='none')
self.vector_artist = None
self.line_collection = LineCollection(np.zeros((0, 2, 2)))
self.axes.add_collection(self.line_collection)
# Scatter density
self.density_auto_limits = DensityMapLimits()
self.density_artist = ScatterDensityArtist(self.axes, [], [], color='white',
vmin=self.density_auto_limits.min,
vmax=self.density_auto_limits.max)
self.axes.add_artist(self.density_artist)
self.mpl_artists = [self.scatter_artist, self.plot_artist,
self.errorbar_artist, self.vector_artist,
self.line_collection, self.density_artist]
self.errorbar_index = 2
self.vector_index = 3
self.reset_cache()
def reset_cache(self):
self._last_viewer_state = {}
self._last_layer_state = {}
@defer_draw
def _update_data(self, changed):
# Layer artist has been cleared already
if len(self.mpl_artists) == 0:
return
try:
x = self.layer[self._viewer_state.x_att].ravel()
except (IncompatibleAttribute, IndexError):
# The following includes a call to self.clear()
self.disable_invalid_attributes(self._viewer_state.x_att)
return
else:
self.enable()
try:
y = self.layer[self._viewer_state.y_att].ravel()
except (IncompatibleAttribute, IndexError):
# The following includes a call to self.clear()
self.disable_invalid_attributes(self._viewer_state.y_att)
return
else:
self.enable()
if self.state.markers_visible:
if self.state.density_map:
self.density_artist.set_xy(x, y)
self.plot_artist.set_data([], [])
self.scatter_artist.set_offsets(np.zeros((0, 2)))
else:
if self.state.cmap_mode == 'Fixed' and self.state.size_mode == 'Fixed':
# In this case we use Matplotlib's plot function because it has much
# better performance than scatter.
self.plot_artist.set_data(x, y)
self.scatter_artist.set_offsets(np.zeros((0, 2)))
self.density_artist.set_xy([], [])
else:
self.plot_artist.set_data([], [])
offsets = np.vstack((x, y)).transpose()
self.scatter_artist.set_offsets(offsets)
self.density_artist.set_xy([], [])
else:
self.plot_artist.set_data([], [])
self.scatter_artist.set_offsets(np.zeros((0, 2)))
self.density_artist.set_xy([], [])
if self.state.line_visible:
if self.state.cmap_mode == 'Fixed':
points = np.array([x, y]).transpose()
self.line_collection.set_segments([points])
else:
# In the case where we want to color the line, we need to over
# sample the line by a factor of two so that we can assign the
# correct colors to segments - if we didn't do this, then
# segments on one side of a point would be a different color
# from the other side. With oversampling, we can have half a
# segment on either side of a point be the same color as a
# point
x_fine = np.zeros(len(x) * 2 - 1, dtype=float)
y_fine = np.zeros(len(y) * 2 - 1, dtype=float)
x_fine[::2] = x
x_fine[1::2] = 0.5 * (x[1:] + x[:-1])
y_fine[::2] = y
y_fine[1::2] = 0.5 * (y[1:] + y[:-1])
points = np.array([x_fine, y_fine]).transpose().reshape(-1, 1, 2)
segments = np.concatenate([points[:-1], points[1:]], axis=1)
self.line_collection.set_segments(segments)
else:
self.line_collection.set_segments(np.zeros((0, 2, 2)))
for eartist in list(self.errorbar_artist[2]):
if eartist is not None:
try:
eartist.remove()
except ValueError:
pass
except AttributeError: # Matplotlib < 1.5
pass
if self.vector_artist is not None:
self.vector_artist.remove()
self.vector_artist = None
if self.state.vector_visible:
if self.state.vx_att is not None and self.state.vy_att is not None:
vx = self.layer[self.state.vx_att].ravel()
vy = self.layer[self.state.vy_att].ravel()
if self.state.vector_mode == 'Polar':
ang = vx
length = vy
# assume ang is anti clockwise from the x axis
vx = length * np.cos(np.radians(ang))
vy = length * np.sin(np.radians(ang))
else:
vx = None
vy = None
if self.state.vector_arrowhead:
hw = 3
hl = 5
else:
hw = 1
hl = 0
v = np.hypot(vx, vy)
vmax = np.nanmax(v)
vx = vx / vmax
vy = vy / vmax
self.vector_artist = self.axes.quiver(x, y, vx, vy, units='width',
pivot=self.state.vector_origin,
headwidth=hw, headlength=hl,
scale_units='width',
scale=10 / self.state.vector_scaling)
self.mpl_artists[self.vector_index] = self.vector_artist
if self.state.xerr_visible or self.state.yerr_visible:
if self.state.xerr_visible and self.state.xerr_att is not None:
xerr = self.layer[self.state.xerr_att].ravel()
else:
xerr = None
if self.state.yerr_visible and self.state.yerr_att is not None:
yerr = self.layer[self.state.yerr_att].ravel()
else:
yerr = None
self.errorbar_artist = self.axes.errorbar(x, y, fmt='none',
xerr=xerr, yerr=yerr)
self.mpl_artists[self.errorbar_index] = self.errorbar_artist
@defer_draw
def _update_visual_attributes(self, changed, force=False):
if not self.enabled:
return
if self.state.markers_visible:
if self.state.density_map:
if self.state.cmap_mode == 'Fixed':
if force or 'color' in changed or 'cmap_mode' in changed:
self.density_artist.set_color(self.state.color)
self.density_artist.set_c(None)
self.density_artist.set_clim(self.density_auto_limits.min,
self.density_auto_limits.max)
elif force or any(prop in changed for prop in CMAP_PROPERTIES):
c = self.layer[self.state.cmap_att].ravel()
set_mpl_artist_cmap(self.density_artist, c, self.state)
if force or 'stretch' in changed:
self.density_artist.set_norm(ImageNormalize(stretch=STRETCHES[self.state.stretch]()))
if force or 'dpi' in changed:
self.density_artist.set_dpi(self._viewer_state.dpi)
if force or 'density_contrast' in changed:
self.density_auto_limits.contrast = self.state.density_contrast
self.density_artist.stale = True
else:
if self.state.cmap_mode == 'Fixed' and self.state.size_mode == 'Fixed':
if force or 'color' in changed:
self.plot_artist.set_color(self.state.color)
if force or 'size' in changed or 'size_scaling' in changed:
self.plot_artist.set_markersize(self.state.size *
self.state.size_scaling)
else:
# TEMPORARY: Matplotlib has a bug that causes set_alpha to
# change the colors back: https://github.com/matplotlib/matplotlib/issues/8953
if 'alpha' in changed:
force = True
if self.state.cmap_mode == 'Fixed':
if force or 'color' in changed or 'cmap_mode' in changed:
self.scatter_artist.set_facecolors(self.state.color)
self.scatter_artist.set_edgecolor('none')
elif force or any(prop in changed for prop in CMAP_PROPERTIES):
c = self.layer[self.state.cmap_att].ravel()
set_mpl_artist_cmap(self.scatter_artist, c, self.state)
self.scatter_artist.set_edgecolor('none')
if force or any(prop in changed for prop in MARKER_PROPERTIES):
if self.state.size_mode == 'Fixed':
s = self.state.size * self.state.size_scaling
s = broadcast_to(s, self.scatter_artist.get_sizes().shape)
else:
s = self.layer[self.state.size_att].ravel()
s = ((s - self.state.size_vmin) /
(self.state.size_vmax - self.state.size_vmin)) * 30
s *= self.state.size_scaling
# Note, we need to square here because for scatter, s is actually
# proportional to the marker area, not radius.
self.scatter_artist.set_sizes(s ** 2)
if self.state.line_visible:
if self.state.cmap_mode == 'Fixed':
if force or 'color' in changed or 'cmap_mode' in changed:
self.line_collection.set_array(None)
self.line_collection.set_color(self.state.color)
elif force or any(prop in changed for prop in CMAP_PROPERTIES):
# Higher up we oversampled the points in the line so that
# half a segment on either side of each point has the right
# color, so we need to also oversample the color here.
c = self.layer[self.state.cmap_att].ravel()
cnew = np.zeros((len(c) - 1) * 2)
cnew[::2] = c[:-1]
cnew[1::2] = c[1:]
set_mpl_artist_cmap(self.line_collection, cnew, self.state)
if force or 'linewidth' in changed:
self.line_collection.set_linewidth(self.state.linewidth)
if force or 'linestyle' in changed:
self.line_collection.set_linestyle(self.state.linestyle)
if self.state.vector_visible and self.vector_artist is not None:
if self.state.cmap_mode == 'Fixed':
if force or 'color' in changed or 'cmap_mode' in changed:
self.vector_artist.set_array(None)
self.vector_artist.set_color(self.state.color)
elif force or any(prop in changed for prop in CMAP_PROPERTIES):
c = self.layer[self.state.cmap_att].ravel()
set_mpl_artist_cmap(self.vector_artist, c, self.state)
if self.state.xerr_visible or self.state.yerr_visible:
for eartist in list(self.errorbar_artist[2]):
if eartist is None:
continue
if self.state.cmap_mode == 'Fixed':
if force or 'color' in changed or 'cmap_mode' in changed:
eartist.set_color(self.state.color)
elif force or any(prop in changed for prop in CMAP_PROPERTIES):
c = self.layer[self.state.cmap_att].ravel()
set_mpl_artist_cmap(eartist, c, self.state)
if force or 'alpha' in changed:
eartist.set_alpha(self.state.alpha)
if force or 'visible' in changed:
eartist.set_visible(self.state.visible)
if force or 'zorder' in changed:
eartist.set_zorder(self.state.zorder)
for artist in [self.scatter_artist, self.plot_artist,
self.vector_artist, self.line_collection,
self.density_artist]:
if artist is None:
continue
if force or 'alpha' in changed:
artist.set_alpha(self.state.alpha)
if force or 'zorder' in changed:
artist.set_zorder(self.state.zorder)
if force or 'visible' in changed:
artist.set_visible(self.state.visible)
self.redraw()
@defer_draw
def _update_scatter(self, force=False, **kwargs):
if (self._viewer_state.x_att is None or
self._viewer_state.y_att is None or
self.state.layer is None):
return
# Figure out which attributes are different from before. Ideally we shouldn't
# need this but currently this method is called multiple times if an
# attribute is changed due to x_att changing then hist_x_min, hist_x_max, etc.
# If we can solve this so that _update_histogram is really only called once
# then we could consider simplifying this. Until then, we manually keep track
# of which properties have changed.
changed = set()
if not force:
for key, value in self._viewer_state.as_dict().items():
if value != self._last_viewer_state.get(key, None):
changed.add(key)
for key, value in self.state.as_dict().items():
if value != self._last_layer_state.get(key, None):
changed.add(key)
self._last_viewer_state.update(self._viewer_state.as_dict())
self._last_layer_state.update(self.state.as_dict())
if force or len(changed & DATA_PROPERTIES) > 0:
self._update_data(changed)
force = True
if force or len(changed & VISUAL_PROPERTIES) > 0:
self._update_visual_attributes(changed, force=force)
def get_layer_color(self):
if self.state.cmap_mode == 'Fixed':
return self.state.color
else:
return self.state.cmap
@defer_draw
def update(self):
self._update_scatter(force=True)
self.redraw()
ball_rad = float(tokens[1])
fig = plt.figure()
ax = fig.add_subplot(111)
ax.invert_yaxis()
ax.axis('equal')
for obs in obstacles:
ax.add_patch(plt.Polygon(obs, fc='#404040'))
ax.add_patch(plt.Circle(target_pos, target_rad, ec='None', fc='red'))
# Draw graph
edges = LineCollection(([dataset[v1][:2], dataset[v2][:2]] for v1, v2 in graph.get_edgelist()))
edges.set_color('Lavender')
edges.set_zorder(1)
ax.add_collection(edges)
# Draw points
params = {}
if args.clustering:
# Open the vertex dendogram
print 'Loading clustering...'
membership = cPickle.load(open(args.clustering, 'rb'))
params['c'] = membership
params['cmap'] = plt.get_cmap('hsv')
# Highlight boundary points
boundary = [v.index for v in graph.vs
if sum((membership[nid] != membership[v.index]
def show_frac_charge(filename=None,bias=False,usevec=False,theta=0,dmu=0.01,target_block=(0,0),append=False,**kwargs):
'''
Show the fractional charge wave functions.
'''
model,expander=get_solving_system(evolutor_type='masked',periodic=False,**kwargs)
if filename is None:
filename='data/frac_W1%s_W2%s_U%s_N%s'%(kwargs.get('K1'),kwargs.get('K2'),kwargs.get('U'),kwargs.get('nsite'))
if not bias:
ket_even=MPS.load(filename+'-even.dat')
ket_odd=MPS.load(filename+'-odd.dat')
#ket_odd=ket_odd-(ket_even.tobra(labels=ket_even.labels)*ket_odd).item()*ket_even
#combine to left-right edge states.
if usevec:
ket_odd,ket_even=ket_odd.state,ket_even.state
#else:
#ket_odd.recanonicalize(tol=1e-8)
ket_left=ket_even#(ket_even+exp(1j*theta)*ket_odd)/sqrt(2.)
ket_right=ket_odd#(ket_even-exp(1j*theta)*ket_odd)/sqrt(2.)
if not usevec:
ket_left.recanonicalize(tol=1e-8) #we must recanonicalize it, for it is not canonical!!!
ket_right.recanonicalize(tol=1e-8)
print ket_left
print ket_right
pls=[dos4mps(spaceconfig=expander.spaceconfig,ket=ket) for ket in [ket_left,ket_right]]
else:
pls=[dos4vec(spaceconfig=model.hgen.spaceconfig,ket=ket) for ket in [ket_left,ket_right]]
else:
suffix='W1%s_W2%s_U%s_N%s_dmu%s_%s.dat'%(kwargs.get('K1'),kwargs.get('K2'),kwargs.get('U'),kwargs.get('nsite'),dmu,target_block)
filename_mps='data/mps_'+suffix
print filename_mps
fname='data/fracdos_'+suffix
#suffix2='W1%s_W2%s_U%s_N%s_dmu%s_%s.dat'%(kwargs.get('K1'),kwargs.get('K2'),kwargs.get('U'),kwargs.get('nsite'),dmu,(0,-1))
#filename_mps2='data/mps_'+suffix2
if append:
pls=loadtxt(fname)[newaxis,:,:]
else:
ket_bias=MPS.load(filename_mps)
#ket_bias=1./sqrt(2)*(MPS.load(filename_mps2)-1j*ket_bias)
#ket_bias.compress()
pls=[dos4mps(spaceconfig=expander.spaceconfig,ket=ket) for ket in [ket_bias]]
savetxt(fname,pls[0].real)
#pls=sum(pls,axis=1)
pls=array(pls)-0.5
nsite=pls.shape[-1]
pls_left=pls[:,:,:nsite/2]
pls_right=pls[:,:,nsite/2:]
print 'occupation in left block -> %s, right block -> %s.'%(sum(pls_left,axis=(-1,-2)),sum(pls_right,axis=(-1,-2)))
if ONSV: return pls
ion()
lw=2
lc='r'
for n in xrange(len(pls)):
pln=pls[n]
ax=subplot(101+n+10*len(pls))
for s in xrange(2):
color='b' if s==0 else 'r'
lc=LineCollection([[(i,0),(i,pln[s,i].real.item())] for i in xrange(model.nsite)])
lc.set_linewidth(lw)
lc.set_color(color)
lc.set_linestyle('--' if s==1 else '-')
ax.add_collection(lc)
ax.autoscale()
ax.margins(0.1)
xlabel('N')
ylabel(r'$\rho-\bar{\rho}$')
pdb.set_trace()
def plot(bmap, X, k_fig, x_next, kappa):
""" Auxillary plotting function
Parameters
----------
bma : EnrichedBayesianModelAveraging object to be plotted
X : The values that have been previously traversed
mode : mode = "predict" if the GaussianProcessEI prediction is disired
or mode = "EI" if the expected improvement is desired
k_fig : The suffix seed for saving the figure
"""
import matplotlib.pyplot as plt
from matplotlib.collections import LineCollection
from matplotlib import colors as cl
from matplotlib import gridspec
# Get the bma
bma = bmap.bma
# Get number of models
nModels = len(bma.quadratic_models)
# Plot ranges
x_min = -5.0
x_max = 5.0
y_min = -200
y_max = 200
colorcycle = ['r', 'b', 'g', 'm', 'y']
# Plot for 1d
num_points = 200
# mini plot dx param
dx = 0.5
# miniplot num points
mini_num_points = 50
dpi = 300
# Create x array to be plotted
x_plot = np.linspace(x_min, x_max, num_points)
x_grid = np.array([x_plot])
# Get mean values at each of the grid points
F = np.zeros(x_plot.shape)
for i in range(len(x_plot)):
F[i] = fun(np.array([x_plot[i]]))
Z_rolled = bma.predict_with_unc(x_grid)
model_weights, errors, N_eff, marginal_likelihoods = bma.estimate_model_weights(x_grid, return_likelihoods=True)
Z = Z_rolled[0,:]
# bma disagreement
S = Z_rolled[1,:]
# bma uncertainty
U = Z_rolled[2,:]
# Get full variance
std = np.sqrt(np.square(S) + np.square(U))
def plt_func(ax):
# Plot function
func_line = ax.plot(x_plot, F)
# Set line properties
plt.setp(func_line, color="black", linewidth=2.0, alpha=0.5)
def plt_data(ax, X):
# Scatter of observations models (sampled models)
for i in range(nModels):
f = bma.quadratic_models[i].get_y()
ax.scatter(X[0,i], f, s=100.0, c="black", alpha=0.5)
def plt_acquisition(ax):
# Get acquisition values:
acq = bmao.calculate_discounted_mean(x_grid, kappa=kappa)
acq_line = ax.plot(x_plot, acq)
plt.setp(acq_line, color="red", linewidth = 2.0, linestyle='--')
# Plot next point
Z_next_rolled = bma.predict(np.array([x_next]))
#ax.scatter(x_next,Z_next_rolled[0,:]+(y_max-y_min)/80., s=100.0, c="red",marker='v')
def plt_mean(ax):
# Plot prediction, and plot function
pred_line = ax.plot(x_plot, Z)
# Set line properties
plt.setp(pred_line, color="blue", linewidth=2.0, alpha=0.5)
def plt_confidence(ax):
# Plot confidence bars for the two types of errors
ax.fill_between(x_plot,Z-S,Z+S, facecolor='blue', interpolate=True, alpha=0.3)
ax.fill_between(x_plot,Z-U,Z+U, facecolor='red', interpolate=True, alpha=0.3)
# Full std bars
upper_min = np.max(np.vstack([Z+S,Z+U]), axis=0)
lower_min = np.min(np.vstack([Z-S,Z-U]), axis=0)
ax.fill_between(x_plot,upper_min,Z+std, facecolor='black', interpolate=True, alpha=0.15)
ax.fill_between(x_plot,Z-std,lower_min, facecolor='black', interpolate=True, alpha=0.15)
def plt_minature(ax):
# Plot minature cuvature plots for each model
dx_mini_plot = np.linspace(-dx, dx, mini_num_points)
dx_mini_grid = np.array([dx_mini_plot])
# For the plotting, we will use the current colorcycle
ax.set_color_cycle(colorcycle)
for i in range(nModels):
model_predictions = bma.model_predictions(x_grid)
line = ax.plot(x_plot, model_predictions[i,:])
# Set line properties for miniplot
plt.setp(line, linewidth=3.0, alpha=0.5, linestyle='-',
dash_capstyle='round')
### Plot 1
fig, ax = plt.subplots(dpi=dpi)
plt_func(ax)
plt_data(ax, X)
plt_minature(ax)
# Plot range
plt.ylim([y_min, y_max])
plt.xlim([x_min, x_max])
plt.savefig("figures/"+str(k_fig)+"_func_obs_.png", dpi=dpi)
### Plot 2
fig, ax = plt.subplots(dpi=dpi)
plt_func(ax)
plt_data(ax, X)
plt_mean(ax)
plt_confidence(ax)
# Plot range
plt.ylim([y_min, y_max])
plt.xlim([x_min, x_max])
plt.savefig("figures/"+str(k_fig)+"_bma_conf_.png", dpi=dpi)
### Plot 3
fig, ax = plt.subplots(dpi=dpi)
plt_func(ax)
plt_data(ax, X)
plt_mean(ax)
plt_acquisition(ax)
# Plot range
plt.ylim([y_min, y_max])
plt.xlim([x_min, x_max])
plt.savefig("figures/"+str(k_fig)+"_bma_acq_.png", dpi=dpi)
### Informative Plot
n_subplot = 5
fig2 = plt.figure(figsize=(8, 8), dpi=dpi)
gs = gridspec.GridSpec(n_subplot, 1, height_ratios=[3, 1, 1, 1, 1])
# Create axis array
ax = []
for i in range(n_subplot):
ax.append(plt.subplot(gs[i]))
# Show the model priors
log_model_priors = bma.estimate_log_model_priors(x_grid)
ax[1]._get_lines.set_color_cycle(colorcycle)
for i in range(nModels):
p1_line = ax[1].plot(x_plot, np.exp(log_model_priors[i,:]))
plt.setp(p1_line, linewidth=3.0, alpha=1.0, linestyle='-',
dash_capstyle='round')
# Plot range
ax[1].set_ylim([0, 1])
ax[1].set_xlim([x_min, x_max])
ax[1].set_ylabel('prior', fontsize=16)
# Plot marginal likelihood proportionalities
ax[2]._get_lines.set_color_cycle(colorcycle)
for i in range(nModels):
p2_line = ax[2].plot(x_plot, np.log(marginal_likelihoods[i,:]))
plt.setp(p2_line, linewidth=3.0, alpha=1.0, linestyle='-',
dash_capstyle='round')
#ax[2].set_ylim([0.00000001, 1])
ax[2].set_ylim(-25,0)
#ax[2].set_yscale('log')
ax[2].set_xlim([x_min, x_max])
ax[2].set_ylabel('ll', fontsize=16)
# Show the model weights
model_weights = bma.estimate_model_weights(x_grid)
ax[3]._get_lines.set_color_cycle(colorcycle)
for i in range(nModels):
p3_line = ax[3].plot(x_plot, model_weights[i,:])
plt.setp(p3_line, linewidth=3.0, alpha=1.0, linestyle='-',
dash_capstyle='round')
# Plot range
ax[3].set_ylim([0, 1])
ax[3].set_xlim([x_min, x_max])
ax[3].set_ylabel('posterior', fontsize=16)
# Show the kernel weights
kernel_weights = bma.calc_kernel_weights(x_grid)
# N_eff
N_eff = np.sum(kernel_weights, 0)
#N_eff_line = ax[4].plot(x_plot, N_eff)
#plt.setp(N_eff_line, linewidth = 3.0, alpha=1.0, linestyle='-',
# color='black')
# Shade in the makeup of N_eff
cumulant = N_eff*0.0
for i in range(nModels):
color = colorcycle[i]
ax[4].fill_between(x_plot,cumulant,cumulant+kernel_weights[i,:], facecolor=color, interpolate=True, alpha=0.35)
cumulant += kernel_weights[i,:]
# Plot range
ax[4].set_ylim([0, nModels])
ax[4].set_xlim([x_min, x_max])
ax[4].set_ylabel('N_eff', fontsize=16)
### Plot alpha weighted by posterior cuvature plots for each model
model_predictions = bma.model_predictions(x_grid)
# For the plotting, we will use the current colorcycle
ax[0]._get_lines.set_color_cycle(colorcycle)
color_cycle = ax[0]._get_lines.color_cycle
for i in range(nModels):
# Max alpha for the plots
max_alpha = 0.7
# Cited from http://matplotlib.1069221.n5.nabble.com/Varying-alpha-in-ListedColormap-not-working-td39950.html
x = x_plot
y = model_predictions[i,:]
scaling = model_weights[i,:]
points = np.array([x, y]).T.reshape(-1, 1, 2)
segments = np.concatenate([points[:-1],points[1:]], axis=1)
# Values to scale by
smin = 0
smax = 1
# Inline function to convert scaling value to alpha value in [0,1]
alpha = lambda s0:(s0-smin)/(smax-smin)
# Create a (rgba) color description for each line segment
cmap = []
# Get the next color in the colorcycle
color = next(color_cycle)
converter = cl.ColorConverter()
# Get the rgb color tuple and convert it to a list
color_rgba = list(converter.to_rgb(color))
# Add placeholder alpha to get color_rgba
color_rgba.append(0.0)
for a in segments:
# The x-value for the segment
x0 = a.mean(0)[0]
# With scaling value of
s0 = np.interp(x0, x, scaling)
# And alpha value of
a0 = alpha(s0)
# Pop the previous alpha and add the current alpha
color_rgba[3] = a0*max_alpha
# Add the rgba entry to the colormap. Make sure to copy the list
# Using list slicing.
cmap.append(color_rgba[:])
# Create the line collection objecft
lc = LineCollection(segments)
lc.set_color(cmap)
# Set line properties.
# Dashed line
lc.set_dashes('-')
# line width 3.0
lc.set_linewidth(3.0)
ax[0].add_collection(lc)
"""
# Normal plot
#p0_line = ax[0].plot(x_plot, model_predictions[i,:])
# Set line properties for miniplot
#plt.setp(p0_line, linewidth=3.0, alpha=model_weights[i,:], linestyle='--',
# dash_capstyle='round')
"""
# Now plot scatter of observations
for i in range(nModels):
f = bma.quadratic_models[i].get_y()
ax[0].scatter(X[0,i],f,s=100.0, c="black", alpha=0.5)
# Plot bma predictions
pred_line = ax[0].plot(x_plot,Z)
# Line properties
plt.setp(pred_line, color="black", alpha=0.3, linewidth=3.0)
# Set the plot range
ax[0].set_xlim(x_min, x_max)
ax[0].set_ylim(y_min, y_max)
# set x axis
ax[4].set_xlabel("x",fontsize=16)
plt.savefig("figures/"+str(k_fig)+"_bma_model_breakdown.png", dpi=dpi)
fig3, ax = plt.subplots(2, sharex=True)
ax[0].plot(x_plot, N_eff)
### Plot of errors
for i in range(nModels):
p1_line = ax[1].plot(x_plot, errors[i,:]+10**-32)
plt.setp(p1_line, linewidth=3.0, alpha=1.0, linestyle='-',
dash_capstyle='round')
# Set log scale
ax[1].set_yscale('log')
plt.savefig("figures/"+str(k_fig)+"_bma_error_breakdown.png", dpi=dpi)
### Likelihood plots
fig4, ax = plt.subplots(2, sharex=True)
kernel_grid = np.logspace(-4.0, 1, num=50)
# Get the likelihoods
unreg_loglikelihood = np.array([bma.loglikelihood(kernel_range, regularization=False, skew=False) for kernel_range in kernel_grid])
reg_loglikelihood = np.array([bma.loglikelihood(kernel_range) for kernel_range in kernel_grid])
# Plot the two terms
ll0 = ax[0].plot(kernel_grid, unreg_loglikelihood)
ax[0].set_xscale('log')
ll1 = ax[1].plot(kernel_grid, reg_loglikelihood)
ax[1].set_xscale('log')
plt.setp(ll0, color="red", linewidth=3.0, alpha=0.5, linestyle='-',
dash_capstyle='round')
plt.setp(ll1, color="red", linewidth=3.0, alpha=0.5, linestyle='-',
dash_capstyle='round')
ax[1].set_xlabel("kernel range",fontsize=16)
plt.savefig("figures/"+str(k_fig)+"_bma_loglikelihood.png", dpi=dpi)
"""
class Anim:
def __init__(
self, eddy, intern=False, sleep_event=0.1, graphic_information=False, **kwargs
):
self.eddy = eddy
x_name, y_name = eddy.intern(intern)
self.t, self.x, self.y = eddy.time, eddy[x_name], eddy[y_name]
self.x_core, self.y_core, self.track = eddy["lon"], eddy["lat"], eddy["track"]
self.graphic_informations = graphic_information
self.pause = False
self.period = self.eddy.period
self.sleep_event = sleep_event
self.mappables = list()
self.field_color = None
self.field_txt = None
self.time_field = False
self.setup(**kwargs)
def setup(
self,
cmap="jet",
lut=None,
field_color="time",
field_txt="track",
range_color=(None, None),
nb_step=25,
figsize=(8, 6),
**kwargs,
):
self.field_color = self.eddy[field_color].astype("f4")
self.field_txt = self.eddy[field_txt]
rg = range_color
if rg[0] is None and rg[1] is None and field_color == "time":
self.time_field = True
else:
rg = (
self.field_color.min() if rg[0] is None else rg[0],
self.field_color.max() if rg[1] is None else rg[1],
)
self.field_color = (self.field_color - rg[0]) / (rg[1] - rg[0])
self.colors = pyplot.get_cmap(cmap, lut=lut)
self.nb_step = nb_step
x_min, x_max = self.x_core.min() - 2, self.x_core.max() + 2
d_x = x_max - x_min
y_min, y_max = self.y_core.min() - 2, self.y_core.max() + 2
d_y = y_max - y_min
# plot
self.fig = pyplot.figure(figsize=figsize, **kwargs)
t0, t1 = self.period
self.fig.suptitle(f"{t0} -> {t1}")
self.ax = self.fig.add_axes((0.05, 0.05, 0.9, 0.9), projection="full_axes")
self.ax.set_xlim(x_min, x_max), self.ax.set_ylim(y_min, y_max)
self.ax.set_aspect("equal")
self.ax.grid()
# init mappable
self.txt = self.ax.text(x_min + 0.05 * d_x, y_min + 0.05 * d_y, "", zorder=10)
self.segs = list()
self.t_segs = list()
self.c_segs = list()
self.contour = LineCollection([], zorder=1)
self.ax.add_collection(self.contour)
self.fig.canvas.draw()
self.fig.canvas.mpl_connect("key_press_event", self.keyboard)
self.fig.canvas.mpl_connect("resize_event", self.reset_bliting)
def reset_bliting(self, event):
self.contour.set_visible(False)
self.txt.set_visible(False)
for m in self.mappables:
m.set_visible(False)
self.fig.canvas.draw()
self.bg_cache = self.fig.canvas.copy_from_bbox(self.ax.bbox)
self.contour.set_visible(True)
self.txt.set_visible(True)
for m in self.mappables:
m.set_visible(True)
def show(self, infinity_loop=False):
pyplot.show(block=False)
# save background for future bliting
self.fig.canvas.draw()
self.bg_cache = self.fig.canvas.copy_from_bbox(self.ax.bbox)
loop = True
t0, t1 = self.period
while loop:
self.now = t0
while True:
dt = self.sleep_event
if not self.pause:
d0 = datetime.now()
self.next()
dt_draw = (datetime.now() - d0).total_seconds()
dt = self.sleep_event - dt_draw
if dt < 0:
# self.sleep_event = dt_draw * 1.01
dt = 1e-10
if dt == 0:
dt = 1e-10
self.fig.canvas.start_event_loop(dt)
if self.now > t1:
break
if infinity_loop:
self.fig.canvas.start_event_loop(0.5)
else:
loop = False
def next(self):
self.now += 1
return self.draw_contour()
def prev(self):
self.now -= 1
return self.draw_contour()
def func_animation(self, frame):
while self.mappables:
self.mappables.pop().remove()
self.now = frame
self.update()
artists = [self.contour, self.txt]
artists.extend(self.mappables)
return artists
def update(self):
m = self.t == self.now
if m.sum():
segs = list()
t = list()
c = list()
for i in where(m)[0]:
segs.append(create_vertice(self.x[i], self.y[i]))
c.append(self.field_color[i])
t.append(self.now)
self.segs.append(segs)
self.c_segs.append(c)
self.t_segs.append(t)
self.contour.set_paths(chain(*self.segs))
if self.time_field:
self.contour.set_color(
self.colors(
[
(self.nb_step - self.now + i) / self.nb_step
for i in chain(*self.c_segs)
]
)
)
else:
self.contour.set_color(self.colors(list(chain(*self.c_segs))))
# linewidth will be link to time delay
self.contour.set_lw(
[
(1 - (self.now - i) / self.nb_step) * 2.5 if i <= self.now else 0
for i in chain(*self.t_segs)
]
)
# Update date txt and info
txt = f"{(timedelta(int(self.now)) + datetime(1950,1,1)).strftime('%Y/%m/%d')}"
if self.graphic_informations:
txt += f"- {1/self.sleep_event:.0f} frame/s"
self.txt.set_text(txt)
# Update id txt
for i in where(m)[0]:
mappable = self.ax.text(
self.x_core[i],
self.y_core[i],
self.field_txt[i],
fontsize=12,
fontweight="demibold",
)
self.mappables.append(mappable)
self.ax.draw_artist(mappable)
self.ax.draw_artist(self.contour)
self.ax.draw_artist(self.txt)
# Remove first segment to keep only T contour
if len(self.segs) > self.nb_step:
self.segs.pop(0)
self.t_segs.pop(0)
self.c_segs.pop(0)
def draw_contour(self):
# select contour for this time step
while self.mappables:
self.mappables.pop().remove()
self.ax.figure.canvas.restore_region(self.bg_cache)
self.update()
# paint updated artist
self.ax.figure.canvas.blit(self.ax.bbox)
def keyboard(self, event):
if event.key == "escape":
exit()
elif event.key == " ":
self.pause = not self.pause
elif event.key == "+":
self.sleep_event *= 0.9
elif event.key == "-":
self.sleep_event *= 1.1
elif event.key == "right" and self.pause:
self.next()
elif event.key == "left" and self.pause:
# we remove 2 step to add 1 so we rewind of only one
self.segs.pop(-1)
self.segs.pop(-1)
self.t_segs.pop(-1)
self.t_segs.pop(-1)
self.c_segs.pop(-1)
self.c_segs.pop(-1)
self.prev()
def mesh( self, points, colors=None, edgecolors='k', edgewidth=None, triangulate='delaunay', setxylim=True, **kwargs ):
'plot elemtwise mesh'
assert isinstance( points, numpy.ndarray ) and points.dtype == float
if colors is not None:
assert isinstance( colors, numpy.ndarray ) and colors.dtype == float
assert points.shape[:-1] == colors.shape
if points.ndim == 3: # gridded data: nxpoints x nypoints x ndims
assert points.shape[-1] == 2
assert colors is not None
data = colors.ravel()
xy = points.reshape( -1, 2 ).T
ind = numpy.arange( xy.shape[1] ).reshape( points.shape[:-1] )
vert1 = numpy.array([ ind[:-1,:-1].ravel(), ind[1:,:-1].ravel(), ind[:-1,1:].ravel() ]).T
vert2 = numpy.array([ ind[1:,1:].ravel(), ind[1:,:-1].ravel(), ind[:-1,1:].ravel() ]).T
triangles = numpy.concatenate( [vert1,vert2], axis=0 )
edges = None
elif points.ndim == 2: # mesh: npoints x ndims
ndims = points.shape[1]
if ndims == 1:
self.plot( points[:,0], colors )
return
else:
assert ndims == 2, 'unsupported: ndims=%s' % ndims
nans = numpy.isnan( points ).all( axis=1 )
split, = numpy.where( nans )
if colors is not None:
assert numpy.isnan( colors[split] ).all()
P = []
N = []
C = []
E = []
npoints = 0
for a, b in zip( numpy.concatenate([[0],split+1]), numpy.concatenate([split,[nans.size]]) ):
np = b - a
if np == 0:
continue
epoints = points[a:b]
if colors is not None:
ecolors = colors[a:b]
if triangulate == 'delaunay':
tri = spatial.Delaunay( epoints )
vertices = tri.vertices
e0 = [ edge[0] for edge in tri.convex_hull ]
e1 = [ edge[1] for edge in tri.convex_hull ]
last = e1.pop()
hull = [ e0.pop(), last ]
while e0:
try:
index = e0.index( last )
last = e1[index]
except ValueError:
index = e1.index( last )
last = e0[index]
e0.pop( index )
e1.pop( index )
hull.append( last )
assert hull[0] == hull[-1]
elif triangulate == 'bezier':
nquad = int( numpy.sqrt(np) + .5 )
ntri = int( numpy.sqrt((2*np)+.25) )
if nquad**2 == np:
ind = numpy.arange(np).reshape(nquad,nquad)
vert1 = numpy.array([ ind[:-1,:-1].ravel(), ind[1:,:-1].ravel(), ind[:-1,1:].ravel() ]).T
vert2 = numpy.array([ ind[1:,1:].ravel(), ind[1:,:-1].ravel(), ind[:-1,1:].ravel() ]).T
vertices = numpy.concatenate( [vert1,vert2], axis=0 )
hull = numpy.concatenate([ ind[:,0], ind[-1,1:], ind[-2::-1,-1], ind[0,-2::-1] ])
elif ntri * (ntri+1) == 2 * np:
vert1 = [ ((2*ntri-i+1)*i)//2+numpy.array([j,j+1,j+ntri-i]) for i in range(ntri-1) for j in range(ntri-i-1) ]
vert2 = [ ((2*ntri-i+1)*i)//2+numpy.array([j+1,j+ntri-i+1,j+ntri-i]) for i in range(ntri-1) for j in range(ntri-i-2) ]
vertices = numpy.concatenate( [vert1,vert2], axis=0 )
hull = numpy.concatenate([ numpy.arange(ntri), numpy.arange(ntri-1,0,-1).cumsum()+ntri-1, numpy.arange(ntri+1,2,-1).cumsum()[::-1]-ntri-1 ])
else:
raise Exception( 'cannot match points to a bezier scheme' )
else:
raise Exception( 'unknown triangulation method %r' % triangulate )
P.append( epoints.T )
N.append( vertices + npoints )
if colors is not None:
C.append( ecolors )
E.append( epoints[hull] )
npoints += np
xy = numpy.concatenate( P, axis=1 )
triangles = numpy.concatenate( N, axis=0 )
if colors is not None:
data = numpy.concatenate( C )
edges = E
else:
raise Exception( 'invalid points shape %r' % ( points.shape, ) )
TriMesh = self._trimesh_class()
polycol = TriMesh( xy, triangles, rasterized=True, **kwargs )
if colors is not None:
polycol.set_array( data )
if edges and edgecolors != 'none':
from matplotlib.collections import LineCollection
linecol = LineCollection( edges, linewidths=(edgewidth,) if edgewidth is not None else None )
linecol.set_color( edgecolors )
self.gca().add_collection( linecol )
self.gca().add_collection( polycol )
self.sci( polycol )
if setxylim:
xmin, ymin = numpy.min( xy, axis=1 )
xmax, ymax = numpy.max( xy, axis=1 )
self.xlim( xmin, xmax )
self.ylim( ymin, ymax )
if edgecolors != 'none':
return polycol, linecol
return polycol
def show_graph(self, fixed=False, show_ids=True):
"""draw the graph"""
import pylab as pl
if not hasattr(self, "graph"):
self.make_graph()
print "showing graph"
# I need to clear the figure and make a new axes object because
# I can't find any other way to remove old colorbars
self.fig.clf()
self.axes = self.fig.add_subplot(111)
ax = self.axes
ax.clear()
graph = self.graph
#get the layout of the nodes from networkx
oldlayout = self.positions
layout = nx.spring_layout(graph, pos=oldlayout)#, fixed=fixed)
self.positions.update(layout)
layout = self.positions
# draw the edges as lines
from matplotlib.collections import LineCollection
linecollection = LineCollection([(layout[u], layout[v]) for u, v in graph.edges()
if u not in self.boundary_nodes and v not in self.boundary_nodes])
linecollection.set_color('k')
ax.add_collection(linecollection)
if self.boundary_nodes:
# draw the edges connecting the boundary nodes as thin lines
from matplotlib.collections import LineCollection
linecollection = LineCollection([(layout[u], layout[v]) for u, v in graph.edges()
if u in self.boundary_nodes or v in self.boundary_nodes])
linecollection.set_color('k')
linecollection.set_linewidth(0.2)
ax.add_collection(linecollection)
markersize = 8**2
# draw the interior nodes
interior_nodes = set(graph.nodes()) - self.boundary_nodes
layoutlist = filter(lambda nxy: nxy[0] in interior_nodes, layout.items())
xypos = np.array([xy for n, xy in layoutlist])
if self._minima_color_value is None:
#color the nodes by energy
color_values = [m.energy for m, xy in layoutlist]
else:
color_values = [self._minima_color_value(m) for m, xy in layoutlist]
#plot the nodes
self._minima_points = ax.scatter(xypos[:,0], xypos[:,1], picker=5,
s=markersize, c=color_values, cmap=pl.cm.autumn)
self._mimima_layout_list = layoutlist
# if not hasattr(self, "colorbar"):
self.colorbar = self.fig.colorbar(self._minima_points)
self._boundary_points = None
self._boundary_list = []
if self.boundary_nodes:
# draw the boundary nodes as empty circles with thin lines
boundary_layout_list = filter(lambda nxy: nxy[0] in self.boundary_nodes, layout.items())
xypos = np.array([xy for n, xy in boundary_layout_list])
#plot the nodes
import matplotlib as mpl
# marker = mpl.markers.MarkerStyle("o", fillstyle="none")
# marker.set_fillstyle("none")
self._boundary_points = ax.scatter(xypos[:,0], xypos[:,1], picker=5,
s=markersize, marker="o", facecolors="none", linewidths=.5)
self._boundary_layout_list = boundary_layout_list
#scale the axes so the points are not cutoff
xmax = max((x for x,y in layout.itervalues() ))
xmin = min((x for x,y in layout.itervalues() ))
ymax = max((y for x,y in layout.itervalues() ))
ymin = min((y for x,y in layout.itervalues() ))
dx = (xmax - xmin)*.1
dy = (ymax - ymin)*.1
ax.set_xlim([xmin-dx, xmax+dx])
ax.set_ylim([ymin-dy, ymax+dy])
import matplotlib.pyplot as plt
# self.fig.relim()
# self.fig.tight_layout()
# plt.tight_layout()
# self.fig.set_tight_layout(True)
# def on_pick(event):
# ind = event.ind[0]
# if event.artist == points:
# min1 = layoutlist[ind][0]
# elif event.artist == boundary_points:
# min1 = boundary_layout_list[ind][0]
# else:
# return True
# print "you clicked on minimum with id", min1._id, "and energy", min1.energy
# self._on_minima_picked(min1)
if self._mpl_cid is not None:
self.canvas.mpl_disconnect(self._mpl_cid)
self._mpl_cid = None
self._mpl_cid = self.fig.canvas.mpl_connect('pick_event', self._on_mpl_pick_event)
self.canvas.draw()
self.app.processEvents()
def plot(self, time, beam=None, maxground=2000, maxalt=500,
iscat=True, gscat=True, title=False, weighted=False, cmap='hot_r',
fig=None, rect=111, ax=None, aax=None, zorder=4):
"""Plot scatter on ground/altitude profile
Parameters
----------
time : datetime.datetime
time of profile
beam : Optional[ ]
beam number
maxground : Optional[int]
maximum ground range [km]
maxalt : Optional[int]
highest altitude limit [km]
iscat : Optional[bool]
show ionospheric scatter
gscat : Optional[bool]
show ground scatter
title : Optional[bool]
Show default title
weighted : Optional[bool]
plot ionospheric scatter relative strength (based on background density and range)
cmap : Optional[str]
colormap used for weighted ionospheric scatter
fig : Optional[pylab.figure]
object (default to gcf)
rect : Optional[int]
subplot spcification
ax : Optional[ ]
Existing main axes
aax : Optional[ ]
Existing auxialary axes
zorder : Optional[int]
Returns
-------
ax : matplotlib.axes
object containing formatting
aax : matplotlib.axes
object containing data
cbax : matplotlib.axes
object containing colorbar
Example
-------
# Show ionospheric scatter
import datetime as dt
from models import raydarn
sTime = dt.datetime(2012, 11, 18, 5)
rto = raydarn.RtRun(sTime, rCode='bks', beam=12)
rto.readRays() # read rays into memory
ax, aax, cbax = rto.rays.plot(sTime, title=True)
rto.readScatter() # read scatter into memory
rto.scatter.plot(sTime, ax=ax, aax=aax)
ax.grid()
written by Sebastien, 2013-04
"""
from davitpy.utils import plotUtils
from matplotlib.collections import LineCollection
import matplotlib.pyplot as plt
import numpy as np
# Set up axes
if not ax and not aax:
ax, aax = plotUtils.curvedEarthAxes(fig=fig, rect=rect,
maxground=maxground, maxalt=maxalt)
else:
ax = ax
aax = aax
if hasattr(ax, 'beam'):
beam = ax.beam
# make sure that the required time and beam are present
assert (time in self.isc.keys() or time in self.gsc.keys()), logging.error('Unkown time %s' % time)
if beam:
assert (beam in self.isc[time].keys()), logging.error('Unkown beam %s' % beam)
else:
beam = self.isc[time].keys()[0]
if gscat and time in self.gsc.keys():
for ir, (el, rays) in enumerate( sorted(self.gsc[time][beam].items()) ):
if len(rays['r']) == 0: continue
_ = aax.scatter(rays['th'], ax.Re*np.ones(rays['th'].shape),
color='0', zorder=zorder)
if iscat and time in self.isc.keys():
if weighted:
wmin = np.min( [ r['w'].min() for r in self.isc[time][beam].values() if r['nstp'] > 0] )
wmax = np.max( [ r['w'].max() for r in self.isc[time][beam].values() if r['nstp'] > 0] )
for ir, (el, rays) in enumerate( sorted(self.isc[time][beam].items()) ):
if rays['nstp'] == 0: continue
t = rays['th']
r = rays['r']*1e-3
spts = np.array([t, r]).T.reshape(-1, 1, 2)
h = rays['h']*1e-3
rel = np.radians( rays['rel'] )
r = np.sqrt( r**2 + h**2 + 2*r*h*np.sin( rel ) )
t = t + np.arcsin( h/r * np.cos( rel ) )
epts = np.array([t, r]).T.reshape(-1, 1, 2)
segments = np.concatenate([spts, epts], axis=1)
lcol = LineCollection( segments, zorder=zorder )
if weighted:
_ = lcol.set_cmap( cmap )
_ = lcol.set_norm( plt.Normalize(0, 1) )
_ = lcol.set_array( ( rays['w'] - wmin ) / wmax )
else:
_ = lcol.set_color('0')
_ = aax.add_collection( lcol )
# Plot title with date ut time and local time
if title:
stitle = _getTitle(time, beam, self.header, None)
ax.set_title( stitle )
# If weighted, plot ionospheric scatter with colormap
if weighted:
# Add a colorbar
cbax = plotUtils.addColorbar(lcol, ax)
_ = cbax.set_ylabel("Ionospheric Scatter")
else: cbax = None
ax.beam = beam
return ax, aax, cbax
#offs = (0.1, 0.0)
#
#from numpy import amax, cos, random, pi
#rs = random.RandomState([12345678])
#
#yy = linspace(0, 2*pi, nverts)
#ym = amax(yy)
#xx = (0.2 + (ym-yy)/ym)**2 * cos(yy-0.4) * 0.5
#segs = []
#for i in range(ncurves):
# xxx = xx + 0.02*rs.randn(nverts)
# curve = list(zip(xxx, yy*100))
# segs.append(curve)
# if i<2:
# print segs
segs = []
segs.append(list(zip(freq, Magvec[:, 1])))
segs.append(list(zip(freqb, Magvecb[:, 1])))
col = LineCollection(segs) #, offsets=offs)
ax4.add_collection(col, autolim=True)
col.set_color(colors)
ax4.autoscale_view()
ax4.set_title('Successive data offsets')
ax4.set_xlabel('Zonal velocity component (m/s)')
#ax4.set_ylabel('Depth (m)')
# Reverse the y-axis so depth increases downward
#ax4.set_ylim(ax4.get_ylim()[::-1])
plt.show()
def plot(bma, X, k_fig):
""" Auxillary plotting function
Parameters
----------
bma : bayesianModelAveraging object to be plotted
X : The values that have been previously traversed
mode : mode = "predict" if the GaussianProcessEI prediction is disired
or mode = "EI" if the expected improvement is desired
k_fig : The suffix seed for saving the figure
"""
import matplotlib.pyplot as plt
from matplotlib.collections import LineCollection
from matplotlib import colors as cl
from matplotlib import gridspec
# Get number of models
nModels = len(bma.quadratic_models)
# Plot ranges
x_min = -3.0
x_max = 3.0
y_min = -100
y_max = 100
# Plot for 1d
num_points = 100
# mini plot dx param
dx = 0.5
# miniplot num points
mini_num_points = 50
# Create x array to be plotted
x_plot = np.linspace(x_min, x_max, num_points)
x_grid = np.array([x_plot])
# Get mean values at each of the grid points
Z = np.zeros(x_plot.shape)
S = np.zeros(x_plot.shape)
F = np.zeros(x_plot.shape)
for i in range(len(x_plot)):
F[i] = fun(np.array([x_plot[i]]))
Z_rolled = bma.predict_with_unc(x_grid)
Z = Z_rolled[0,:]
# bma disagreement
S = Z_rolled[1,:]
# bma uncertainty
U = Z_rolled[2,:]
### Plot 1
fig, ax = plt.subplots()
# Plot prediction, and plot function
pred_line = ax.plot(x_plot,Z)
func_line = ax.plot(x_plot,F)
# Set line properties
plt.setp(pred_line, color="blue", linewidth=2.0)
plt.setp(func_line, color="black", linewidth=2.0)
# Scatter of observations
for i in range(nModels):
f = bma.quadratic_models[i][0]
ax.scatter(X[0,i],f,s=100.0, c="black", alpha=0.5)
# Plot disagreement bars
ax.fill_between(x_plot,Z-S,Z+S, facecolor='blue', interpolate=True, alpha=0.3)
ax.fill_between(x_plot,Z-U,Z+U, facecolor='red', interpolate=True, alpha=0.3)
# Plot minature cuvature plots for each model
dx_mini_plot = np.linspace(-dx, dx, mini_num_points)
dx_mini_grid = np.array([dx_mini_plot])
for i in range(nModels):
model_predictions = bma.model_predictions(dx_mini_grid+X[0,i])
line = ax.plot(dx_mini_plot+X[0,i], model_predictions[i,:])
# Set line properties for miniplot
plt.setp(line, color="green", linewidth=3.0, alpha=0.5, linestyle='--',
dash_capstyle='round')
# Plot range
plt.ylim([y_min, y_max])
plt.xlim([x_min, x_max])
plt.savefig("figures/"+str(k_fig)+"_bma_vs_func_.png")
### Plot 2
n_subplot = 4
fig2 = plt.figure(figsize=(8, 8))
gs = gridspec.GridSpec(4, 1, height_ratios=[3, 1, 1, 1])
# Create axis array
ax = []
for i in range(n_subplot):
ax.append(plt.subplot(gs[i]))
#fig, ax = plt.subplots(4, sharex=True)
# Show the model priors
model_priors = bma.estimate_model_priors(x_grid)
for i in range(nModels):
p1_line = ax[1].plot(x_plot, model_priors[i,:])
plt.setp(p1_line, linewidth=3.0, alpha=1.0, linestyle='-',
dash_capstyle='round')
# Plot range
ax[1].set_ylim([0, 1])
ax[1].set_xlim([x_min, x_max])
# Show the model weights
model_weights = bma.estimate_model_weights(x_grid)
for i in range(nModels):
p2_line = ax[2].plot(x_plot, model_weights[i,:])
plt.setp(p2_line, linewidth=3.0, alpha=1.0, linestyle='-',
dash_capstyle='round')
# Plot range
ax[2].set_ylim([0, 1])
ax[2].set_xlim([x_min, x_max])
# Show the kernel values
kernel_weights = bma.calc_relevance_weights(x_grid)
for i in range(nModels):
p3_line = ax[3].plot(x_plot, kernel_weights[i,:])
plt.setp(p3_line, linewidth=3.0, alpha=1.0, linestyle='-',
dash_capstyle='round')
### Plot alpha weighted by posterior cuvature plots for each model
model_predictions = bma.model_predictions(x_grid)
# For the plotting, we will use the current colorcycle
color_cycle = ax[0]._get_lines.color_cycle
for i in range(nModels):
# Max alpha for the plots
max_alpha = 0.7
# Cited from http://matplotlib.1069221.n5.nabble.com/Varying-alpha-in-ListedColormap-not-working-td39950.html
x = x_plot
y = model_predictions[i,:]
scaling = model_weights[i,:]
points = np.array([x, y]).T.reshape(-1, 1, 2)
segments = np.concatenate([points[:-1],points[1:]], axis=1)
# Values to scale by
smin = 0
smax = 1
# Inline function to convert scaling value to alpha value in [0,1]
alpha = lambda s0:(s0-smin)/(smax-smin)
# Create a (rgba) color description for each line segment
cmap = []
# Get the next color in the colorcycle
color = next(color_cycle)
converter = cl.ColorConverter()
# Get the rgb color tuple and convert it to a list
color_rgba = list(converter.to_rgb(color))
# Add placeholder alpha to get color_rgba
color_rgba.append(0.0)
for a in segments:
# The x-value for the segment
x0 = a.mean(0)[0]
# With scaling value of
s0 = np.interp(x0, x, scaling)
# And alpha value of
a0 = alpha(s0)
# Pop the previous alpha and add the current alpha
color_rgba[3] = a0*max_alpha
# Add the rgba entry to the colormap. Make sure to copy the list
# Using list slicing.
cmap.append(color_rgba[:])
# Create the line collection objecft
lc = LineCollection(segments)
lc.set_color(cmap)
# Set line properties.
# Dashed line
lc.set_dashes('--')
# line width 3.0
lc.set_linewidth(3.0)
ax[0].add_collection(lc)
"""
# Normal plot
#p0_line = ax[0].plot(x_plot, model_predictions[i,:])
# Set line properties for miniplot
#plt.setp(p0_line, linewidth=3.0, alpha=model_weights[i,:], linestyle='--',
# dash_capstyle='round')
"""
# Now plot scatter of observations
for i in range(nModels):
f = bma.quadratic_models[i][0]
ax[0].scatter(X[0,i],f,s=100.0, c="black", alpha=0.5)
# Plot bma predictions
pred_line = ax[0].plot(x_plot,Z)
# Line properties
plt.setp(pred_line, color="black", alpha=0.3, linewidth=3.0)
# Set the plot range
ax[0].set_xlim(x_min, x_max)
ax[0].set_ylim(y_min, y_max)
plt.savefig("figures/"+str(k_fig)+"_bma_model_breakdown.png")
fig3, ax = plt.subplots(2, sharex=True)
model_weights, errors, N_eff = bma.estimate_model_weights(x_grid, return_errors=True)
ax[0].plot(x_plot, N_eff)
### Plot of errors
for i in range(nModels):
p1_line = ax[1].plot(x_plot, errors[i,:])
plt.setp(p1_line, linewidth=3.0, alpha=1.0, linestyle='-',
dash_capstyle='round')
# Set log scale
ax[1].set_yscale('log')
plt.savefig("figures/"+str(k_fig)+"_bma_error_breakdown.png")
def plot(self, show_minima=False, show_trees=False, linewidth=0.5, axes=None,
title=None):
"""draw the disconnectivity graph using matplotlib
don't forget to call calculate() first
also, you must call pyplot.show() to actually see the plot
"""
from matplotlib.collections import LineCollection
import matplotlib.pyplot as plt
self.line_segments, self.line_colours = self._get_line_segments(self.tree_graph, eoffset=self.eoffset)
# get the axes object
if axes is not None:
ax = axes
else:
try:
ax = self.axes
except AttributeError:
fig = plt.figure(figsize=(6, 7))
fig.set_facecolor('white')
ax = fig.add_subplot(111, adjustable='box')
# set up how the figure should look
ax.tick_params(axis='y', direction='out')
ax.yaxis.tick_left()
# make the borders a bit prettier
ax.spines['left'].set_color('black')
ax.spines['left'].set_linewidth(0.5)
ax.spines['top'].set_color('none')
ax.spines['bottom'].set_color('none')
ax.spines['right'].set_color('none')
# plt.box(on=True)
if title is not None:
ax.set_title(title)
# draw the minima as points
if show_minima:
xpos, minima = self.get_minima_layout()
energies = [m.energy for m in minima]
ax.plot(xpos, energies, 'o')
# draw the line segments
# use LineCollection because it's much faster than drawing the lines individually
linecollection = LineCollection([[(x[0], y[0]), (x[1], y[1])] for x, y in self.line_segments])
linecollection.set_linewidth(linewidth)
linecollection.set_color(self.line_colours)
ax.add_collection(linecollection)
# scale the axes appropriately
# note: do not call ax.relim(). As of matplotlib version 1.3
# ax.relim() does not take Collections into account so it does
# not compute the limits correctly. ax.autoscale_view() seems to work just fine
ax.autoscale_view(scalex=True, scaley=True, tight=False)
ax.set_ybound(upper=self.Emax)
xmin, xmax = ax.get_xlim()
ax.set_xlim(xmin - 0.5, xmax + 0.5)
# remove xtics
# note: the xticks are removed after ax.autoscale_view() is called.
# If it is the other way around the lines are too close the image border
ax.set_xticks([])
self.axes = ax
def plot_linestring_collection(ax, geoms, colors_or_values, plot_values,
vmin=None, vmax=None, cmap=None,
linewidth=1.0, **kwargs):
"""
Plots a collection of LineString and MultiLineString geometries to `ax`
Parameters
----------
ax : matplotlib.axes.Axes
where shapes will be plotted
geoms : a sequence of `N` LineStrings and/or MultiLineStrings (can be mixed)
colors_or_values : a sequence of `N` values or RGBA tuples
It should have 1:1 correspondence with the geometries (not their components).
plot_values : bool
If True, `colors_or_values` is interpreted as a list of values, and will
be mapped to colors using vmin/vmax/cmap (which become required).
Otherwise `colors_or_values` is interpreted as a list of colors.
Returns
-------
collection : matplotlib.collections.Collection that was plotted
"""
from matplotlib.collections import LineCollection
components, component_colors_or_values = _flatten_multi_geoms(
geoms, colors_or_values)
# LineCollection does not accept some kwargs.
if 'markersize' in kwargs:
del kwargs['markersize']
segments = [np.array(linestring)[:, :2] for linestring in components]
collection = LineCollection(segments,
linewidth=linewidth, **kwargs)
if plot_values:
collection.set_array(np.array(component_colors_or_values))
collection.set_cmap(cmap)
collection.set_clim(vmin, vmax)
else:
# set_color magically sets the correct combination of facecolor and
# edgecolor, based on collection type.
collection.set_color(component_colors_or_values)
# If the user set facecolor and/or edgecolor explicitly, the previous
# call to set_color might have overridden it (remember, the 'color' may
# have come from plot_series, not from the user). The user should be
# able to override matplotlib's default behavior, by setting them again
# after set_color.
if 'facecolor' in kwargs:
collection.set_facecolor(kwargs['facecolor'])
if 'edgecolor' in kwargs:
collection.set_edgecolor(kwargs['edgecolor'])
ax.add_collection(collection, autolim=True)
ax.autoscale_view()
return collection
