def plot_spatio_temporal_r2_values(dat):
"""Calculate the signed r^2 values and plot them in a heatmap.
Parameters
----------
dat : Data
epoched data
"""
r2 = proc.calculate_signed_r_square(dat)
r2 *= -1
max = np.max(np.abs(r2))
plt.imshow(r2.T, aspect='auto', interpolation='None', vmin=-max, vmax=max, cmap='RdBu')
ax = plt.gca()
# TODO: sort front-back, left-right
# use the locators to fine-tune the ticks
mask = [True if chan.endswith('z') else False for chan in dat.axes[-1]]
ax.yaxis.set_major_locator(ticker.FixedLocator(np.nonzero(mask)[0]))
ax.yaxis.set_major_formatter(ticker.IndexFormatter(dat.axes[-1]))
ax.xaxis.set_major_locator(ticker.MultipleLocator( np.max(dat.axes[-2]) // 100))
ax.xaxis.set_major_formatter(ticker.IndexFormatter(['%.1f' % i for i in dat.axes[-2]]))
plt.xlabel('%s [%s]' % (dat.names[-2], dat.units[-2]))
plt.ylabel('%s [%s]' % (dat.names[-1], dat.units[-1]))
plt.tight_layout(True)
plt.colorbar()
plt.grid(True)
def plot(results):
'''
Create a plot comparing multiple learners.
`results` is a list of tuples containing:
(title, expected values, actual values)
All the elements in results will be plotted.
'''
global minmax
# Using subplots to display the results on the same X axis
fig, plts = plt.subplots(nrows=len(results), figsize=(8, 8))
fig.canvas.set_window_title('Predicting data')
# Show each element in the plots returned from plt.subplots()
for subplot, (title, y, y_pred) in zip(plts, results):
# Configure each subplot to have no tick marks
# (these are meaningless for the sample dataset)
subplot.xaxis.set_major_formatter(ticker.IndexFormatter(frame["Year"]))
# Label the vertical axis
subplot.set_ylabel('Trees Sold')
# Set the title for the subplot
subplot.set_title(title)
# Plot the actual data and the prediction
subplot.plot(y, 'g', label='actual')
subplot.plot(y_pred, 'r--', label='predicted')
# Shade the area between the predicted and the actual values
subplot.fill_between(
# Generate X values [0, 1, 2, ..., len(y)-2, len(y)-1]
np.arange(0, len(y), 1),
y,
y_pred,
color='r',
alpha=0.2)
# Mark the extent of the training data
subplot.axvline(np.floor(len(y) * 0.8),
linestyle='--',
color='0',
alpha=0.2)
# Include a legend in each subplot
subplot.legend()
# Let matplotlib handle the subplot layout
fig.tight_layout()
# ==================================
# Display the plot in interactive UI
plt.show()
# Closing the figure allows matplotlib to release the memory used.
plt.close()
def _string_coord_axis_tick_labels(string_axes, axes=None):
"""Apply tick labels for string coordinates."""
ax = axes if axes else plt.gca()
for axis, ticks in string_axes.items():
formatter = mpl_ticker.IndexFormatter(ticks)
locator = mpl_ticker.MaxNLocator(integer=True)
this_axis = getattr(ax, axis)
this_axis.set_major_formatter(formatter)
this_axis.set_major_locator(locator)
def plot(self, show_signals=True) -> Plot:
plot = Plot()
# TODO
# create dict instance attr that these calls pull values from
# would allow for more customization of charts
plot.add_line(self.plotted_y_data,
x_data=self.plotted_x_data,
color='b')
plot.add_line(self.center, x_data=self.plotted_x_data, color='k')
plot.add_line(self.upper_action_limit,
x_data=self.plotted_x_data,
color='r')
plot.add_line(self.lower_action_limit,
x_data=self.plotted_x_data,
color='r')
plot.add_line(self.upper_warning_limit,
x_data=self.plotted_x_data,
color=config.ORANGE) # orange
plot.add_line(self.lower_warning_limit,
x_data=self.plotted_x_data,
color=config.ORANGE)
plot.add_line(self.plus_one_stdev,
x_data=self.plotted_x_data,
color='g')
plot.add_line(self.minus_one_stdev,
x_data=self.plotted_x_data,
color='g')
if show_signals:
plot.show_signals(self.signals,
x_data=self.plotted_x_data,
y_data=self.plotted_y_data)
if self.x_labels:
x_axis = plot.axes.xaxis
x_axis.set_major_formatter(
mticker.IndexFormatter([
f'{val.month}/{val.day}'
if isinstance(val, datetime) else val
for val in self.x_labels
]))
self._format_plot(plot)
return plot
def plotTimeInterval(self, start, stop, normalize=False):
# slize measures to plot
pressureSlize = self.getPressures(withLabels=False).loc[start:stop, :]
flowsSlize = self.getFlows(withLabels=False).loc[start:stop]
# demandsSlize = self.getDemands(withLabels=False).loc[start:stop, :]
labelSlize = self.getLabels().loc[start:stop]
if normalize:
pressureSlize = pressureSlize.apply(normalizeDf, axis=1)
flowsSlize = flowsSlize.apply(normalizeDf, axis=1)
# plot
fig, ax = plt.subplots(3, sharex=True)
# dax = demandsSlize.plot(ax=ax[0])
# dax.set_ylabel("Demand")
# dax.get_legend().set_visible(False)
pax = pressureSlize.plot(ax=ax[0])
pax.set_ylabel("Pressure")
pax.get_legend().set_visible(False)
fax = flowsSlize.plot(ax=ax[1])
fax.set_ylabel("Flow")
fax.get_legend().set_visible(False)
lax = labelSlize.plot(ax=ax[2])
lax.set_ylabel("Label")
lax.get_legend().set_visible(False)
# prettify plot
fig.subplots_adjust(hspace=0)
handles, labels = pax.get_legend_handles_labels()
fig.legend(handles,
labels,
loc="center left",
bbox_to_anchor=(0.6, 0.5),
ncol=2)
ticklabels = pressureSlize.index
lax.xaxis.set_major_formatter(ticker.IndexFormatter(ticklabels))
pax.yaxis.set_major_formatter(ticker.FormatStrFormatter('%.2f'))
plt.xticks(rotation=90)
plt.subplots_adjust(bottom=0.4)
plt.tight_layout(rect=[0, 0, 0.6, 1])
plt.show()
def plot_results(name, real_returns, cash, max_dd,
max_duration, max_dd_idx, max_duration_idx, hwm_idx):
plt.plot(real_returns, label='log_returns')
# plt.ylim(ymin = 0.)
# plt.plot(normal_returns, label='normal_returns')
# real_returns.plot()
plt.plot((hwm_idx, max_dd_idx),
(real_returns[hwm_idx], real_returns[max_dd_idx]), color='black')
plt.annotate('max dd ({0:.2f}%)'.format(max_dd * 100.0),
xy=(max_dd_idx, real_returns[max_dd_idx]),
xycoords='data', xytext=(0, -50),
textcoords='offset points',
arrowprops=dict(facecolor='black', shrink=0.05))
max_duration_start_idx = max_duration_idx - max_duration
max_duration_x1x2 = (max_duration_start_idx, max_duration_idx)
max_duration_y1y2 = (real_returns[max_duration_start_idx],
real_returns[max_duration_start_idx])
plt.plot(max_duration_x1x2, max_duration_y1y2, color='black')
plt.annotate('max dd duration ({} days)'.format(max_duration),
xy=((max_duration_start_idx + max_duration_idx) / 2,
real_returns[max_duration_start_idx]),
xycoords='data',
xytext=(-100, 30), textcoords='offset points',
arrowprops=dict(facecolor='black', shrink=0.05))
plt.plot(cash, label='cash')
plt.title(name)
plt.legend()
# Format x-axis with dates
# dates = real_returns.index.to_pydatetime()
dates = real_returns.index.map(lambda t: t.strftime('%Y-%m-%d'))
plt.gca().xaxis.set_major_formatter(ticker.IndexFormatter(dates))
plt.gcf().autofmt_xdate()
plt.show()
"""
def showMatrix(matrix, x_array=None, y_array=None, **kwargs):
"""Show a matrix using :meth:`~matplotlib.axes.Axes.imshow`. Curves on x- and y-axis can be added.
:arg matrix: Matrix to be displayed.
:type matrix: :class:`~numpy.ndarray`
:arg x_array: Data to be plotted above the matrix.
:type x_array: :class:`~numpy.ndarray`
:arg y_array: Data to be plotted on the left side of the matrix.
:type y_array: :class:`~numpy.ndarray`
:arg percentile: A percentile threshold to remove outliers, i.e. only showing data within *p*-th
to *100-p*-th percentile.
:type percentile: float"""
import matplotlib.pyplot as plt
from matplotlib import cm, ticker
from matplotlib.gridspec import GridSpec, GridSpecFromSubplotSpec
from matplotlib.collections import LineCollection
from matplotlib.pyplot import imshow, gca, sca, sci
p = kwargs.pop('percentile', None)
if p is not None:
vmin = np.percentile(matrix, p)
vmax = np.percentile(matrix, 100 - p)
else:
vmin = vmax = None
W = H = 8
ticklabels = kwargs.pop('ticklabels', None)
allticks = kwargs.pop(
'allticks', False
) # this argument is temporary and will be replaced by better implementation
origin = kwargs.pop('origin', 'lower')
if x_array is not None and y_array is not None:
nrow = 2
ncol = 2
i = 1
j = 1
width_ratios = [1, W]
height_ratios = [1, H]
aspect = 'auto'
elif x_array is not None and y_array is None:
nrow = 2
ncol = 1
i = 1
j = 0
width_ratios = [W]
height_ratios = [1, H]
aspect = 'auto'
elif isinstance(y_array, Phylo.BaseTree.Tree):
nrow = 2
ncol = 2
i = 1
j = 1
width_ratios = [W, W]
height_ratios = [H, H]
aspect = 'auto'
elif x_array is None and y_array is not None:
nrow = 1
ncol = 2
i = 0
j = 1
width_ratios = [1, W]
height_ratios = [H]
aspect = 'auto'
else:
nrow = 1
ncol = 1
i = 0
j = 0
width_ratios = [W]
height_ratios = [H]
aspect = None
main_index = (i, j)
upper_index = (i - 1, j)
left_index = (i, j - 1)
complex_layout = nrow > 1 or ncol > 1
cb = kwargs.pop('colorbar', True)
if complex_layout:
if cb:
outer = GridSpec(1, 2, width_ratios=[15, 1], hspace=0.)
gs = GridSpecFromSubplotSpec(nrow,
ncol,
subplot_spec=outer[0],
width_ratios=width_ratios,
height_ratios=height_ratios,
hspace=0.,
wspace=0.)
gs_bar = GridSpecFromSubplotSpec(nrow,
1,
subplot_spec=outer[1],
height_ratios=height_ratios,
hspace=0.,
wspace=0.)
else:
gs = GridSpec(nrow,
ncol,
width_ratios=width_ratios,
height_ratios=height_ratios,
hspace=0.,
wspace=0.)
lines = []
if nrow > 1:
ax1 = plt.subplot(gs[upper_index])
if isinstance(y_array, Phylo.BaseTree.Tree):
pass
else:
ax1.set_xticklabels([])
y = x_array
x = np.arange(len(y))
points = np.array([x, y]).T.reshape(-1, 1, 2)
segments = np.concatenate([points[:-1], points[1:]], axis=1)
cmap = cm.jet(y)
lcy = LineCollection(segments, array=x, linewidths=1, cmap='jet')
lines.append(lcy)
ax1.add_collection(lcy)
ax1.set_xlim(x.min(), x.max())
ax1.set_ylim(y.min(), y.max())
ax1.axis('off')
if ncol > 1:
ax2 = plt.subplot(gs[left_index])
if isinstance(y_array, Phylo.BaseTree.Tree):
Phylo.draw(y_array, do_show=False, axes=ax2, **kwargs)
else:
ax2.set_xticklabels([])
y = y_array
x = np.arange(len(y))
points = np.array([y, x]).T.reshape(-1, 1, 2)
segments = np.concatenate([points[:-1], points[1:]], axis=1)
cmap = cm.jet(y)
lcx = LineCollection(segments, array=y, linewidths=1, cmap='jet')
lines.append(lcx)
ax2.add_collection(lcx)
ax2.set_xlim(y.min(), y.max())
ax2.set_ylim(x.min(), x.max())
ax2.invert_xaxis()
ax2.axis('off')
if complex_layout:
ax3 = plt.subplot(gs[main_index])
else:
ax3 = gca()
kwargs['origin'] = origin
if not 'cmap' in kwargs:
kwargs['cmap'] = 'jet'
im = ax3.imshow(matrix, aspect=aspect, vmin=vmin, vmax=vmax, **kwargs)
#ax3.set_xlim([-0.5, matrix.shape[0]+0.5])
#ax3.set_ylim([-0.5, matrix.shape[1]+0.5])
if ticklabels is not None:
ax3.xaxis.set_major_formatter(ticker.IndexFormatter(ticklabels))
if ncol == 1:
ax3.yaxis.set_major_formatter(ticker.IndexFormatter(ticklabels))
if allticks:
ax3.xaxis.set_major_locator(ticker.IndexLocator(offset=0.5, base=1.))
ax3.yaxis.set_major_locator(ticker.IndexLocator(offset=0.5, base=1.))
else:
ax3.xaxis.set_major_locator(ticker.AutoLocator())
ax3.xaxis.set_minor_locator(ticker.AutoMinorLocator())
ax3.yaxis.set_major_locator(ticker.AutoLocator())
ax3.yaxis.set_minor_locator(ticker.AutoMinorLocator())
if ncol > 1:
ax3.yaxis.set_major_formatter(ticker.NullFormatter())
colorbar = None
if cb:
if complex_layout:
ax4 = plt.subplot(gs_bar[-1])
colorbar = plt.colorbar(mappable=im, cax=ax4)
else:
colorbar = plt.colorbar(mappable=im)
sca(ax3)
sci(im)
return im, lines, colorbar
def showMatrix(matrix, x_array=None, y_array=None, **kwargs):
"""Show a matrix using :meth:`~matplotlib.axes.Axes.imshow`. Curves on x- and y-axis can be added.
:arg matrix: matrix to be displayed
:type matrix: :class:`~numpy.ndarray`
:arg x_array: data to be plotted above the matrix
:type x_array: :class:`~numpy.ndarray`
:arg y_array: data to be plotted on the left side of the matrix
:type y_array: :class:`~numpy.ndarray`
:arg percentile: a percentile threshold to remove outliers, i.e. only showing data within *p*-th
to *100-p*-th percentile
:type percentile: float
:arg interactive: turn on or off the interactive options
:type interactive: bool
"""
from matplotlib import ticker
from matplotlib.gridspec import GridSpec
from matplotlib.collections import LineCollection
from matplotlib.pyplot import gca, sca, sci, colorbar, subplot
p = kwargs.pop('percentile', None)
vmin = vmax = None
if p is not None:
vmin = np.percentile(matrix, p)
vmax = np.percentile(matrix, 100 - p)
vmin = kwargs.pop('vmin', vmin)
vmax = kwargs.pop('vmax', vmax)
lw = kwargs.pop('linewidth', 1)
W = H = kwargs.pop('ratio', 6)
ticklabels = kwargs.pop('ticklabels', None)
xticklabels = kwargs.pop('xticklabels', ticklabels)
yticklabels = kwargs.pop('yticklabels', ticklabels)
show_colorbar = kwargs.pop('colorbar', True)
allticks = kwargs.pop(
'allticks', False
) # this argument is temporary and will be replaced by better implementation
interactive = kwargs.pop('interactive', True)
cmap = kwargs.pop('cmap', 'jet')
origin = kwargs.pop('origin', 'lower')
tree_mode = False
try:
from Bio import Phylo
except ImportError:
raise ImportError('Phylo module could not be imported. '
'Reinstall ProDy or install Biopython '
'to solve the problem.')
tree_mode = isinstance(y_array, Phylo.BaseTree.Tree)
if x_array is not None and y_array is not None:
nrow = 2
ncol = 2
i = 1
j = 1
width_ratios = [1, W]
height_ratios = [1, H]
aspect = 'auto'
elif x_array is not None and y_array is None:
nrow = 2
ncol = 1
i = 1
j = 0
width_ratios = [W]
height_ratios = [1, H]
aspect = 'auto'
elif x_array is None and y_array is not None:
nrow = 1
ncol = 2
i = 0
j = 1
width_ratios = [1, W]
height_ratios = [H]
aspect = 'auto'
else:
nrow = 1
ncol = 1
i = 0
j = 0
width_ratios = [W]
height_ratios = [H]
aspect = None
main_index = (i, j)
upper_index = (i - 1, j)
left_index = (i, j - 1)
complex_layout = nrow > 1 or ncol > 1
ax1 = ax2 = ax3 = None
if complex_layout:
gs = GridSpec(nrow,
ncol,
width_ratios=width_ratios,
height_ratios=height_ratios,
hspace=0.,
wspace=0.)
lines = []
if nrow > 1:
ax1 = subplot(gs[upper_index])
if not tree_mode:
ax1.set_xticklabels([])
y = x_array
xp, yp = interpY(y)
points = np.array([xp, yp]).T.reshape(-1, 1, 2)
segments = np.concatenate([points[:-1], points[1:]], axis=1)
lcy = LineCollection(segments, array=yp, linewidths=lw, cmap=cmap)
lines.append(lcy)
ax1.add_collection(lcy)
ax1.set_xlim(xp.min(), xp.max())
ax1.set_ylim(yp.min(), yp.max())
ax1.axis('off')
if ncol > 1:
ax2 = subplot(gs[left_index])
if tree_mode:
Phylo.draw(y_array, do_show=False, axes=ax2)
else:
ax2.set_xticklabels([])
y = y_array
xp, yp = interpY(y)
points = np.array([yp, xp]).T.reshape(-1, 1, 2)
segments = np.concatenate([points[:-1], points[1:]], axis=1)
lcx = LineCollection(segments, array=yp, linewidths=lw, cmap=cmap)
lines.append(lcx)
ax2.add_collection(lcx)
ax2.set_xlim(yp.min(), yp.max())
ax2.set_ylim(xp.min(), xp.max())
ax2.invert_xaxis()
ax2.axis('off')
if complex_layout:
ax3 = subplot(gs[main_index])
else:
ax3 = gca()
im = ax3.imshow(matrix,
aspect=aspect,
vmin=vmin,
vmax=vmax,
cmap=cmap,
origin=origin,
**kwargs)
#ax3.set_xlim([-0.5, matrix.shape[0]+0.5])
#ax3.set_ylim([-0.5, matrix.shape[1]+0.5])
if xticklabels is not None:
ax3.xaxis.set_major_formatter(ticker.IndexFormatter(xticklabels))
if yticklabels is not None and ncol == 1:
ax3.yaxis.set_major_formatter(ticker.IndexFormatter(yticklabels))
if allticks:
ax3.xaxis.set_major_locator(ticker.IndexLocator(offset=0.5, base=1.))
ax3.yaxis.set_major_locator(ticker.IndexLocator(offset=0.5, base=1.))
else:
ax3.xaxis.set_major_locator(ticker.AutoLocator())
ax3.xaxis.set_minor_locator(ticker.AutoMinorLocator())
ax3.yaxis.set_major_locator(ticker.AutoLocator())
ax3.yaxis.set_minor_locator(ticker.AutoMinorLocator())
if ncol > 1:
ax3.yaxis.set_major_formatter(ticker.NullFormatter())
cb = None
if show_colorbar:
if nrow > 1:
axes = [ax1, ax2, ax3]
while None in axes:
axes.remove(None)
s = H / (H + 1.)
cb = colorbar(mappable=im, ax=axes, anchor=(0, 0), shrink=s)
else:
cb = colorbar(mappable=im)
sca(ax3)
sci(im)
if interactive:
from prody.utilities import ImageCursor
from matplotlib.pyplot import connect
cursor = ImageCursor(ax3, im)
connect('button_press_event', cursor.onClick)
return im, lines, cb
def showLines(*args, **kwargs):
"""
Show 1-D data using :func:`~matplotlib.axes.Axes.plot`.
:arg x: (optional) x coordinates. *x* can be an 1-D array or a 2-D matrix of
column vectors.
:type x: `~numpy.ndarray`
:arg y: data array. *y* can be an 1-D array or a 2-D matrix of
column vectors.
:type y: `~numpy.ndarray`
:arg dy: an array of variances of *y* which will be plotted as a
band along *y*. It should have the same shape with *y*.
:type dy: `~numpy.ndarray`
:arg lower: an array of lower bounds which will be plotted as a
band along *y*. It should have the same shape with *y* and should be
paired with *upper*.
:type lower: `~numpy.ndarray`
:arg upper: an array of upper bounds which will be plotted as a
band along *y*. It should have the same shape with *y* and should be
paired with *lower*.
:type upper: `~numpy.ndarray`
:arg alpha: the transparency of the band(s) for plotting *dy*.
:type alpha: float
:arg beta: the transparency of the band(s) for plotting *miny* and *maxy*.
:type beta: float
:arg ticklabels: user-defined tick labels for x-axis.
:type ticklabels: list
"""
# note for developers: this function serves as a low-level
# plotting function which provides basic utilities for other
# plotting functions. Therefore showFigure is not handled
# in this function as it should be already handled in the caller.
ticklabels = kwargs.pop('ticklabels', None)
dy = kwargs.pop('dy', None)
miny = kwargs.pop('lower', None)
maxy = kwargs.pop('upper', None)
alpha = kwargs.pop('alpha', 0.5)
beta = kwargs.pop('beta', 0.25)
gap = kwargs.pop('gap', False)
labels = kwargs.pop('label', None)
from matplotlib import cm, ticker
from matplotlib.pyplot import figure, gca, xlim
ax = gca()
lines = ax.plot(*args, **kwargs)
polys = []
for i, line in enumerate(lines):
color = line.get_color()
x, y = line.get_data()
if gap:
x_new, y_new = addEnds(x, y)
line.set_data(x_new, y_new)
else:
x_new, y_new = x, y
if labels is not None:
if np.isscalar(labels):
line.set_label(labels)
else:
try:
line.set_label(labels[i])
except IndexError:
raise ValueError(
'The number of labels ({0}) and that of y ({1}) do not match.'
.format(len(labels), len(line)))
# the following function needs to be here so that line exists
def sub_array(a, i, tag='a'):
ndim = 0
if a is not None:
if np.isscalar(a[0]):
ndim = 1 # a plain list (array)
else:
ndim = 2 # a nested list (array)
else:
return None
if ndim == 1:
_a = a
else:
try:
_a = a[i]
except IndexError:
raise ValueError(
'The number of {2} ({0}) and that of y ({1}) do not match.'
.format(len(miny), len(line), tag))
if len(_a) != len(y):
raise ValueError(
'The shapes of {2} ({0}) and y ({1}) do not match.'.format(
len(_miny), len(y), tag))
return _a
if miny is not None and maxy is not None:
_miny = sub_array(miny, i)
_maxy = sub_array(maxy, i)
if gap:
_, _miny = addEnds(x, _miny)
_, _maxy = addEnds(x, _maxy)
poly = ax.fill_between(x_new,
_miny,
_maxy,
alpha=beta,
facecolor=color,
edgecolor=None,
linewidth=1,
antialiased=True)
polys.append(poly)
if dy is not None:
_dy = sub_array(dy, i)
if gap:
_, _dy = addEnds(x, _dy)
poly = ax.fill_between(x_new,
y_new - _dy,
y_new + _dy,
alpha=alpha,
facecolor=color,
edgecolor=None,
linewidth=1,
antialiased=True)
polys.append(poly)
ax.margins(x=0)
if ticklabels is not None:
if callable(ticklabels):
ax.get_xaxis().set_major_formatter(
ticker.FuncFormatter(ticklabels))
else:
ax.get_xaxis().set_major_formatter(
ticker.IndexFormatter(ticklabels))
ax.xaxis.set_major_locator(ticker.AutoLocator())
ax.xaxis.set_minor_locator(ticker.AutoMinorLocator())
return lines, polys
def makePlotFromRuleset(ruleset,
allRules=False,
filepath='results/temporary_ruleset_plot',
viewResults=True,
saveResults=False):
"""
Plots a rule set's similarity matrix of rule interactions and dominances.
**Args**:
**ruleset**: :class:`rules.Ruleset` object that contains the
list of rules and the rule interaction arrays.
**kwargs**:
**allRules**: (Optional) If true, shows even interactions that never
occur because rule definitions are mutually exclusive. 'True' gives
the most accurate plot, but can be overwhelminly busy if the ruleset is
large (>5 rules or so). Default False.
**filepath**: (Optional) Path/name at which to save plot. Default
``results/temporary_rule_plot``.
**viewResults**: (Optional) If true, displays plot immediately after
creation. Default True.
**saveResults**: (Optional) If true, save plot. Default False.
"""
if __name__ == '__main__':
calledFromInterpreter = True
else:
calledFromInterpreter = False
if filepath != 'results/temporary_ruleset_plot':
saveResults = True
#What rules are we plotting here?
#For x:
these_rules = ruleset.rulelist
xticks = [a.__class__.__name__ for a in these_rules]
#For y: What are the rules with all offsets that we're plotting here
these_rules_offset = [False]
max_rule_length, min_rule_length = rules.rule_max_min(these_rules)
for r in these_rules:
for o in range(1 - r.size, max_rule_length):
these_rules_offset.append((r, o))
these_rules_offset.append(False)
yticks = [' ' for x in range(1 + len(these_rules_offset))]
for x in range(len(these_rules_offset)):
if these_rules_offset[x]:
(r, o) = these_rules_offset[x]
yticks[x] = '%s (offset %s)' % (r.__class__.__name__, str(o))
#Set up the plot
plottitle = (unicode('Matrix of rule interactions from rule set "') +
unicode(str(ruleset.name)) + unicode('"'))
fig = plt.figure()
ax = fig.add_subplot(111, title=plottitle)
ax.set_axisbelow(True)
# Starting x value
current_x = 0
rule_bar_height = 2.3 / (8 + max_rule_length * 2.0
) # To keep bars from overlapping, set 1.8 to 1
rule_jump = 3 * max_rule_length - 1
# For each rule in the ruleset...
for i in range(len(these_rules)):
ruleA = these_rules[i]
# ...draw rule column
rule_start_x = current_x + max_rule_length
_makerule(ax, rule_start_x, ruleA.size, H=2 * len(yticks) + 2)
# ...matched against every other rule in the ruleset
for j in range(len(these_rules)):
ruleB = these_rules[j]
# ...in every possible offset possibility
all_o = range(-1 * (ruleB.size - 1), ruleA.size)
for o in all_o:
keycolor = 'never'
if (ruleB, o) in ruleset.coexistence_array[ruleA]:
keycolor = 'unknown'
if (ruleB, o, 'coexist') in ruleset.coexistence_array[ruleA]:
keycolor = 'coexist'
if (ruleB, o, 'conflict') in ruleset.coexistence_array[ruleA]:
keycolor = 'conflict'
if ruleB == ruleA and o == 0:
keycolor = 'self'
#Show all the rules, or just the ones that can coexist?
if allRules == True:
this_y = these_rules_offset.index((ruleB, o))
_makeruleline(
ax,
rule_start_x + o,
this_y,
ruleB.size,
H=rule_bar_height,
existance=keycolor,
)
elif keycolor != 'never':
this_y = these_rules_offset.index((ruleB, o))
_makeruleline(
ax,
rule_start_x + o,
this_y,
ruleB.size,
H=rule_bar_height,
existance=keycolor,
)
current_x = current_x + rule_jump
#Time to format plot!
if ruleset.name == 'Saint Lambert (Full)':
yticks = [y.strip('SLRule_') for y in yticks]
#Deal with y-axis
ax.set_ylabel('Rules')
ax.yaxis.set_major_locator(mpltick.MultipleLocator(1))
ax.yaxis.set_minor_locator(mpltick.MultipleLocator(1))
ax.yaxis.set_minor_formatter(mpltick.IndexFormatter(yticks))
ax.yaxis.set_major_formatter(mpltick.NullFormatter())
ax.set_ylim(0, len(yticks) - 2)
#Deal with x-axis
ax.set_xlabel('Rules \n(Each vertical dotted ' + \
'line represents a single bass note to be figured)')
ax.set_xlim(0, rule_jump * len(xticks))
ax.xaxis.set_major_locator(
mpltick.IndexLocator(rule_jump, max_rule_length - 1))
ax.xaxis.set_minor_locator(mpltick.MultipleLocator(1))
ax.set_xticklabels(xticks, ha='left')
ax.xaxis.grid(True, which='minor')
ax.grid(True, ls='--')
#Add legend
lgd = _makerulelegend(ax, type='ruleset', allRules=allRules)
#Make sure image is sized in accordance with the number of rows/columns.
fig.set_size_inches(3 * len(xticks), .5 * len(yticks))
#Save it?
if saveResults:
filepath = filepath + '.pdf'
fig.savefig(filepath,
dpi=fig.dpi,
bbox_extra_artists=(lgd, ),
bbox_inches='tight')
print 'saved at %s' % filepath
#Open saved version?
if viewResults:
os.system("open " + filepath)
#Show it?
if viewResults == True and calledFromInterpreter == True:
fig.show()
def eviction_stat_reuse_dist_plot(reader,
algorithm,
cache_size,
mode,
time_interval,
cache_params=None,
**kwargs):
"""
:param reader:
:param algorithm:
:param cache_size:
:param mode:
:param time_interval:
:param cache_params:
:param kwargs:
:return:
"""
plot_params = prepPlotParams(
"reuse distance of evicted elements by {}".format(algorithm),
"time({})".format(mode), "reuse dist/cache size",
"eviction_stat_reuse_dist_{}_{}_{}_{}_{}_{}.png".format(
reader.file_loc[reader.file_loc.rfind('/') + 1:], algorithm,
cache_size, mode, time_interval, cache_params), **kwargs)
alg = cache_alg_mapping[algorithm.lower()]
assert alg == "Optimal", "Currently only Optimal is supported"
# get reuse distance of evicted elements by given algorithm
rd_array = mimircache.c_eviction_stat.get_stat(reader.cReader,
algorithm=alg,
cache_size=cache_size,
stat_type="reuse_dist")
# generate break points for bucketing the reuse_dist array
bp = cHeatmap().get_breakpoints(reader, mode, time_interval)
pos = 1
count = 0
matrix = np.zeros((len(bp), 20))
for i in range(len(rd_array)):
# no eviction at this timestamp
if rd_array[i] < 0:
if i == bp[pos]:
for j in range(20):
if count:
matrix[pos - 1][j] /= count
else:
matrix[pos - 1][j] = np.nan
pos += 1
count = 0
continue
# check the bucket for the reuse dist of the evicted element
y = float(rd_array[i]) / cache_size
if y < 1:
y = ceil(y * 10)
elif y > 10:
y = 19
else:
y = ceil(y) + 9
matrix[pos - 1][y] += 1
count += 1
if i == bp[pos]:
for j in range(20):
matrix[pos - 1][j] /= count
pos += 1
count = 0
# y could be zero, which means originally rd_array[i]=0, meaning MRU
for j in range(20):
if count != 0:
matrix[pos - 1][j] /= count
else:
matrix[pos - 1][j] = np.nan
majorLocator = MultipleLocator(2)
minorLocator = MultipleLocator(1)
xticks = ticker.FuncFormatter(
lambda x, pos: '{:2.0f}%'.format(x * 100 / len(bp)))
yticks = ticker.IndexFormatter([
0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 2.0, 3.0, 4.0,
5.0, 6.0, 7.0, 8.0, 9.0, 10.0
])
plt.gca().xaxis.set_major_formatter(xticks)
plt.gca().yaxis.set_major_formatter(yticks)
plt.gca().yaxis.set_major_locator(majorLocator)
plt.gca().yaxis.set_minor_locator(minorLocator)
img = plt.imshow(matrix.T,
interpolation='nearest',
origin='lower',
aspect='auto',
vmin=0,
vmax=1)
cb = plt.colorbar(img)
plt.title(plot_params['title'])
plt.xlabel(plot_params['xlabel'])
plt.ylabel(plot_params['ylabel'])
plt.savefig(plot_params['figname'], dpi=600)
try:
plt.show()
except:
pass
plt.clf()
INFO("plot is saved at the same directory")
def test_formatting(self, x, label):
formatter = mticker.IndexFormatter(['label0', 'label1', 'label2'])
assert formatter(x) == label
def test_formatting(self, x, label):
with cbook._suppress_matplotlib_deprecation_warning():
formatter = mticker.IndexFormatter(['label0', 'label1', 'label2'])
assert formatter(x) == label
def showData(*args, **kwargs):
"""
Show data using :func:`~matplotlib.axes.Axes.plot`.
:arg x: (optional) x coordinates. *x* can be an 1-D array or a 2-D matrix of
column vectors.
:type x: `~numpy.ndarray`
:arg y: data array. *y* can be an 1-D array or a 2-D matrix of
column vectors.
:type y: `~numpy.ndarray`
:arg dy: an array of variances of *y* which will be plotted as a
band along *y*. It should have the same shape with *y*.
:type dy: `~numpy.ndarray`
:arg alpha: the transparency of the band(s).
:type alpha: float
:arg ticklabels: user-defined tick labels for x-axis.
:type ticklabels: list
"""
# note for developers: this function serves as a low-level
# plotting function which provides basic utilities for other
# plotting functions. Therefore showFigure is not handled
# in this function as it should be already handled in the caller.
ticklabels = kwargs.pop('ticklabels', None)
dy = kwargs.pop('dy', None)
alpha = kwargs.pop('alpha', 0.5)
gap = kwargs.pop('gap', False)
from matplotlib import cm, ticker
from matplotlib.pyplot import figure, gca, xlim
ax = gca()
lines = ax.plot(*args, **kwargs)
polys = []
if dy is not None:
dy = np.array(dy)
if dy.ndim == 1:
n, = dy.shape
m = 1
elif dy.ndim == 2:
n, m = dy.shape
else:
raise ValueError('dy should be either 1-D or 2-D.')
for i, line in enumerate(lines):
color = line.get_color()
x, y = line.get_data()
if m != 1 and m != len(lines) or n != len(y):
raise ValueError('The shapes of dy and y do not match.')
if dy.ndim == 1:
_dy = dy
else:
_dy = dy[:, i]
if gap:
x_new, y_new = addBreaks(x, y)
line.set_data(x_new, y_new)
_, _dy = addBreaks(x, _dy)
else:
x_new, y_new = x, y
poly = ax.fill_between(x_new,
y_new - _dy,
y_new + _dy,
alpha=alpha,
facecolor=color,
edgecolor=None,
linewidth=1,
antialiased=True)
polys.append(poly)
ax.margins(x=0)
if ticklabels is not None:
ax.get_xaxis().set_major_formatter(ticker.IndexFormatter(ticklabels))
ax.xaxis.set_major_locator(ticker.AutoLocator())
ax.xaxis.set_minor_locator(ticker.AutoMinorLocator())
return lines, polys
def trading_annotation(df,
strategy_name,
ticker_code,
params,
uid,
formation_date=1,
dpi=None):
'''
df <pd.DataFrame>: a DataFrame object, containing 'Buy' and 'Sell' columns for annotation.
strategy_name <str>: The strategy name for finding the dedicated column. eg 'Morning Doji Star', 'Three Black Crows'.
params <dict / list? / pd.DataFrame?>: parameters for the dedicated strategy. Will be displayed in the exported chart.
uid <str>: Thd unique id for the parameter combination. eg '001', '002'.
formation_date <int>: To be decided whether include this or not.
dpi <int>: The dpi of the exported image. If the image is not big and want a clearer image, user could try to set this option to 300 or 400.
If the image is too large (displaying all historical data), just set dpi to None (default is 75).
'''
df = df.copy()
ticker_code = str(ticker_code)
h_size = len(df) // 20
fig, ax = plt.subplots(dpi=dpi)
mpl_finance.candlestick2_ohlc(ax,
df['open'],
df['high'],
df['low'],
df['close'],
width=0.6,
colorup='green',
colordown='red')
signal_annotation = df[df[strategy_name]]
buy_annotation = df[df['Buy']]
sell_annotation = df[df['Sell']]
# Annotating the graph.
# Yellow indicates detection of the signal, Green indicates the buying action, Red indicates the selling action.
for i in signal_annotation.index:
pos1 = i - formation_date + 0.5
pos2 = i + 0.5
ax.axvspan(pos1, pos2, fill=True, alpha=0.3, color='yellow')
for i in buy_annotation.index:
pos1 = i - formation_date + 0.5
pos2 = i + 0.5
ax.axvspan(pos1, pos2, fill=True, alpha=0.3, color='green')
for i in sell_annotation.index:
pos1 = i - formation_date + 0.5
pos2 = i + 0.5
ax.axvspan(pos1, pos2, fill=True, alpha=0.3, color='red')
ax.xaxis.set_major_formatter(ticker.IndexFormatter(df['date_time']))
fig.autofmt_xdate()
# Adding parameter dict to the graph.
try:
if type(params) == dict:
for y, key in enumerate(params):
ax.text(0.01,
0.9 - y / (2 * len(params)),
f'{key}: {params[key]}',
horizontalalignment='left',
verticalalignment='top',
transform=ax.transAxes)
if type(params) == list:
for i in range(len(params)):
ax.text(0.01,
0.9 - i / (2 * len(params)),
f'{i}: {params[i]}',
horizontalalignment='left',
verticalalignment='top',
transform=ax.transAxes)
except:
pass
plt.title(f'{strategy_name}: {ticker_code}')
fig.savefig(f'graph_{ticker_code}_{strategy_name}_{uid}_.png')
plt.show()
all_trajects_average.plot()
ax.set_xlabel("Number of flips")
ax.yaxis.set_major_formatter(tick.StrMethodFormatter('${x:,.0f}'))
ax.set_title("100,000 trajectories - 60 flips")
fig.savefig('images/100,000 trajectories - 60 flips.png')
# Now make histograms. First, make the histogram of the 100,000 trajectory end values, and then of only the people that made more than $10,000.
fig, ax = plt.subplots()
(all_trajects_end_vals / 1000000).hist(grid=False, bins=200)
ax.set_yscale("log")
ax.yaxis.set_major_formatter(tick.StrMethodFormatter('{x:,.0f}'))
ax.xaxis.set_major_locator(tick.MultipleLocator(1))
ax.xaxis.set_major_formatter(
tick.IndexFormatter([
'$0', '$1M', '$2M', '$3M', '$4M', '$5M', '$6M', '$7M', '$8M', '$9M',
'$10M'
]))
ax.set_xlabel("Dollars won")
ax.set_ylabel("Number of players")
ax.set_title("Histogram of 100,000 trajectories, 60 flips each")
fig.savefig('images/Histogram 100,000 trajectories - 60 flips.png')
fig, ax = plt.subplots()
(all_trajects_end_vals[all_trajects_end_vals > 10000] / 1000000).hist(
color="maroon", grid=False, bins=200)
ax.set_yscale("log")
ax.yaxis.set_major_formatter(tick.StrMethodFormatter('{x:,.0f}'))
ax.xaxis.set_major_locator(tick.MultipleLocator(1))
ax.xaxis.set_major_formatter(
tick.IndexFormatter([
'$0', '$1M', '$2M', '$3M', '$4M', '$5M', '$6M', '$7M', '$8M', '$9M',
def cartography(symbol,
dataframe,
cheese=None,
adj=None,
pivot_points=dict(),
chart_path='./charts/active.png',
*ignore):
"""Charting for IVy candles."""
global plt
plt.close('all')
if verbose: print(f'Cartography: creating chart for {symbol}...')
timestamps = dataframe.index.tolist()
data_len = len(timestamps)
data_range = range(data_len)
cdl_open = dataframe['open'].tolist()
cdl_high = dataframe['high'].tolist()
cdl_low = dataframe['low'].tolist()
cdl_close = dataframe['close'].tolist()
cdl_vol = dataframe['volume'].tolist()
cdl_wema = dataframe['money_wema'].tolist()
cdl_mid = dataframe['money_mid'].tolist()
cdl_dh = dataframe['money_dh'].tolist()
cdl_dl = dataframe['money_dl'].tolist()
vol_wema = dataframe['volume_wema'].tolist()
vol_mid = dataframe['volume_mid'].tolist()
vol_dh = dataframe['volume_dh'].tolist()
fs = (19.20, 10.80)
dpi = 100
fig = plt.figure(figsize=fs, dpi=dpi, constrained_layout=False)
sargs = dict(ncols=1, nrows=2, figure=fig, height_ratios=[4, 1])
spec = gridspec.GridSpec(**sargs)
ax1 = fig.add_subplot(spec[0, 0])
ax2 = fig.add_subplot(spec[1, 0], sharex=ax1)
plt.xticks(data_range, timestamps, rotation=21, fontweight='bold')
plt.subplots_adjust(left=0.08,
bottom=0.20,
right=0.92,
top=0.95,
wspace=0,
hspace=0.08)
ax1.grid(True, color=(0.3, 0.3, 0.3))
ax1.set_ylabel('Price', fontweight='bold')
ax1.set_xlim(((data_range[0] - 2), (data_range[-1] + 2)))
ylim_low = min(cdl_low)
ylim_high = max(cdl_high)
ax1.set_ylim((ylim_low * 0.98, ylim_high * 1.02))
ax1.set_yticks(cdl_close)
ax1.set_yticklabels(cdl_close)
ax1.yaxis.set_major_formatter(mticker.EngFormatter())
ax1.yaxis.set_major_locator(mticker.AutoLocator())
ax1.xaxis.set_major_formatter(mticker.IndexFormatter(timestamps))
ax1.xaxis.set_major_locator(mticker.AutoLocator())
ax2.grid(True, color=(0.4, 0.4, 0.4))
ax2.set_ylabel('Volume', fontweight='bold')
ax2.yaxis.set_major_formatter(mticker.EngFormatter())
ax2.yaxis.set_major_locator(mticker.AutoLocator())
xticks = ax1.xaxis.get_ticklabels()
plt.setp(xticks[:], visible=False)
# Dynamic width stuff
tbb = ax1.get_tightbbox(fig.canvas.get_renderer()).get_points()
xb = tbb[1][0] - tbb[0][0]
wid_base = (xb / data_len) * 0.5
wid_wick = wid_base * 0.21
wid_cdls = wid_base * 0.89
wid_line = wid_base * 0.34
# Pivot Points plots
pivots = list(pivot_points.keys())
if len(pivots) > 0:
freqs = list(pivot_points.values())
f_min = min(freqs)
f_max = max(freqs)
shades = dict()
for i in range(f_max - f_min):
shades[i + f_min] = round(((f_max - i) / f_max), 2)
pkws = {'linestyle': 'solid', 'linewidth': wid_line}
for price in pivots:
shade = 0
freq = pivot_points[price]
for f in shades:
if f <= freq:
shade = 1 - shades[f]
else:
break
pkws['color'] = (0.25, 0, 0.25, shade)
ax1.plot((0, data_len), (price, price), **pkws)
# Per candle plots
signal_y = [min(cdl_dl), max(cdl_dh)]
for i in data_range:
x_loc = [i, i]
# Signals
if cheese:
cdl_date = timestamps[i].strftime('%Y-%m-%d %H:%M')
lw = 1 + data_range[-1]
sig_args = dict(linestyle='solid', linewidth=wid_base)
if cdl_date in cheese:
buy_sig = cheese[cdl_date]['buy']
sell_sig = cheese[cdl_date]['sell']
for sig in buy_sig:
if sig[0] == symbol:
sig_args['color'] = (0, 1, 0, 0.5)
ax1.plot(x_loc, signal_y, **sig_args)
for sig in sell_sig:
if sig[0] == symbol:
sig_args['color'] = (1, 0, 0, 0.5)
ax1.plot(x_loc, signal_y, **sig_args)
# Candles
wick_data = [cdl_low[i], cdl_high[i]]
candle_data = [cdl_close[i], cdl_open[i]]
ax1.plot(x_loc,
wick_data,
color='white',
linestyle='solid',
linewidth=wid_wick,
alpha=1)
if cdl_close[i] > cdl_open[i]:
cdl_color = (0.33, 1, 0.33, 1)
else:
cdl_color = (1, 0.33, 0.33, 1)
ax1.plot(x_loc,
candle_data,
color=cdl_color,
linestyle='solid',
linewidth=wid_cdls,
alpha=1)
# Volume
volume_data = [0, cdl_vol[i]]
ax2.plot(x_loc,
volume_data,
color=(0.33, 0.33, 1, 1),
linestyle='solid',
linewidth=wid_cdls)
# Per sample plots
pkws = {'linestyle': 'solid', 'linewidth': wid_line}
pkws['label'] = f'Money: {round(cdl_wema[-1], 2)}'
pkws['color'] = (0.4, 0.7, 0.4, 0.8)
ax1.plot(data_range, cdl_wema, **pkws)
pkws['label'] = None
ax2.plot(data_range, vol_wema, **pkws)
pkws['label'] = f'Mid: {round(cdl_mid[-1], 2)}'
pkws['color'] = (0.7, 0.7, 1, 0.7)
ax1.plot(data_range, cdl_mid, **pkws)
pkws['label'] = None
ax2.plot(data_range, vol_mid, **pkws)
pkws['linestyle'] = 'dotted'
pkws['linewidth'] = wid_line * 0.67
pkws['label'] = f'DevHigh: {round(cdl_dh[-1], 2)}'
ax1.plot(data_range, cdl_dh, **pkws)
pkws['label'] = None
ax2.plot(data_range, vol_dh, **pkws)
pkws['label'] = f'DevLow: {round(cdl_dl[-1], 2)}'
ax1.plot(data_range, cdl_dl, **pkws)
# Finalize
ts = timestamps[-1].strftime('%Y-%m-%d %H:%M')
res = adj if adj else 'None'
rnc = round(cdl_close[-1], 3)
t = f'[ {rnc} ] {symbol} @ {ts} (resample: {res})'
fig.suptitle(t, fontsize=18)
fig.legend(ncol=4, loc='lower center', fontsize='xx-large', fancybox=True)
plt.savefig(str(chart_path), dpi=dpi)
plt.close(fig)
if verbose: print("Cartography: chart's done!")
return False
def showMatrix(matrix, x_array=None, y_array=None, **kwargs):
"""Show a matrix using :meth:`~matplotlib.axes.Axes.imshow`. Curves on x- and y-axis can be added.
:arg matrix: matrix to be displayed
:type matrix: :class:`~numpy.ndarray`
:arg x_array: data to be plotted above the matrix
:type x_array: :class:`~numpy.ndarray`
:arg y_array: data to be plotted on the left side of the matrix
:type y_array: :class:`~numpy.ndarray`
:arg percentile: a percentile threshold to remove outliers, i.e. only showing data within *p*-th
to *100-p*-th percentile
:type percentile: float
:arg interactive: turn on or off the interactive options
:type interactive: bool
:arg xtickrotation: how much to rotate the xticklabels in degrees
default is 0
:type xtickrotation: float
"""
from matplotlib import ticker
from matplotlib.gridspec import GridSpec
from matplotlib.collections import LineCollection
from matplotlib.pyplot import gca, sca, sci, colorbar, subplot
from .drawtools import drawTree
p = kwargs.pop('percentile', None)
vmin = vmax = None
if p is not None:
vmin = np.percentile(matrix, p)
vmax = np.percentile(matrix, 100-p)
vmin = kwargs.pop('vmin', vmin)
vmax = kwargs.pop('vmax', vmax)
vcenter = kwargs.pop('vcenter', None)
norm = kwargs.pop('norm', None)
if vcenter is not None and norm is None:
if PY3K:
try:
from matplotlib.colors import DivergingNorm
except ImportError:
from matplotlib.colors import TwoSlopeNorm as DivergingNorm
norm = DivergingNorm(vmin=vmin, vcenter=0., vmax=vmax)
else:
LOGGER.warn('vcenter cannot be used in Python 2 so norm remains None')
lw = kwargs.pop('linewidth', 1)
W = H = kwargs.pop('ratio', 6)
ticklabels = kwargs.pop('ticklabels', None)
xticklabels = kwargs.pop('xticklabels', ticklabels)
yticklabels = kwargs.pop('yticklabels', ticklabels)
xtickrotation = kwargs.pop('xtickrotation', 0.)
show_colorbar = kwargs.pop('colorbar', True)
cb_extend = kwargs.pop('cb_extend', 'neither')
allticks = kwargs.pop('allticks', False) # this argument is temporary and will be replaced by better implementation
interactive = kwargs.pop('interactive', True)
cmap = kwargs.pop('cmap', 'jet')
origin = kwargs.pop('origin', 'lower')
try:
from Bio import Phylo
except ImportError:
raise ImportError('Phylo module could not be imported. '
'Reinstall ProDy or install Biopython '
'to solve the problem.')
tree_mode_y = isinstance(y_array, Phylo.BaseTree.Tree)
tree_mode_x = isinstance(x_array, Phylo.BaseTree.Tree)
if x_array is not None and y_array is not None:
nrow = 2; ncol = 2
i = 1; j = 1
width_ratios = [1, W]
height_ratios = [1, H]
aspect = 'auto'
elif x_array is not None and y_array is None:
nrow = 2; ncol = 1
i = 1; j = 0
width_ratios = [W]
height_ratios = [1, H]
aspect = 'auto'
elif x_array is None and y_array is not None:
nrow = 1; ncol = 2
i = 0; j = 1
width_ratios = [1, W]
height_ratios = [H]
aspect = 'auto'
else:
nrow = 1; ncol = 1
i = 0; j = 0
width_ratios = [W]
height_ratios = [H]
aspect = kwargs.pop('aspect', None)
main_index = (i, j)
upper_index = (i-1, j)
left_index = (i, j-1)
complex_layout = nrow > 1 or ncol > 1
ax1 = ax2 = ax3 = None
if complex_layout:
gs = GridSpec(nrow, ncol, width_ratios=width_ratios,
height_ratios=height_ratios, hspace=0., wspace=0.)
## draw matrix
if complex_layout:
ax3 = subplot(gs[main_index])
else:
ax3 = gca()
im = ax3.imshow(matrix, aspect=aspect, vmin=vmin, vmax=vmax,
norm=norm, cmap=cmap, origin=origin, **kwargs)
#ax3.set_xlim([-0.5, matrix.shape[0]+0.5])
#ax3.set_ylim([-0.5, matrix.shape[1]+0.5])
if xticklabels is not None:
ax3.xaxis.set_major_formatter(ticker.IndexFormatter(xticklabels))
if yticklabels is not None and ncol == 1:
ax3.yaxis.set_major_formatter(ticker.IndexFormatter(yticklabels))
if allticks:
ax3.xaxis.set_major_locator(ticker.IndexLocator(offset=0.5, base=1.))
ax3.yaxis.set_major_locator(ticker.IndexLocator(offset=0.5, base=1.))
else:
locator = ticker.AutoLocator()
locator.set_params(integer=True)
minor_locator = ticker.AutoMinorLocator()
ax3.xaxis.set_major_locator(locator)
ax3.xaxis.set_minor_locator(minor_locator)
locator = ticker.AutoLocator()
locator.set_params(integer=True)
minor_locator = ticker.AutoMinorLocator()
ax3.yaxis.set_major_locator(locator)
ax3.yaxis.set_minor_locator(minor_locator)
if ncol > 1:
ax3.yaxis.set_major_formatter(ticker.NullFormatter())
## draw x_ and y_array
lines = []
if nrow > 1:
ax1 = subplot(gs[upper_index])
if tree_mode_x:
Y, X = drawTree(x_array, label_func=None, orientation='vertical',
inverted=True)
miny = min(Y.values())
maxy = max(Y.values())
minx = min(X.values())
maxx = max(X.values())
ax1.set_xlim(minx-.5, maxx+.5)
ax1.set_ylim(miny, 1.05*maxy)
else:
ax1.set_xticklabels([])
y = x_array
xp, yp = interpY(y)
points = np.array([xp, yp]).T.reshape(-1, 1, 2)
segments = np.concatenate([points[:-1], points[1:]], axis=1)
lcy = LineCollection(segments, array=yp, linewidths=lw, cmap=cmap)
lines.append(lcy)
ax1.add_collection(lcy)
ax1.set_xlim(xp.min()-.5, xp.max()+.5)
ax1.set_ylim(yp.min(), yp.max())
if ax3.xaxis_inverted():
ax2.invert_xaxis()
ax1.axis('off')
if ncol > 1:
ax2 = subplot(gs[left_index])
if tree_mode_y:
X, Y = drawTree(y_array, label_func=None, inverted=True)
miny = min(Y.values())
maxy = max(Y.values())
minx = min(X.values())
maxx = max(X.values())
ax2.set_ylim(miny-.5, maxy+.5)
ax2.set_xlim(minx, 1.05*maxx)
else:
ax2.set_xticklabels([])
y = y_array
xp, yp = interpY(y)
points = np.array([yp, xp]).T.reshape(-1, 1, 2)
segments = np.concatenate([points[:-1], points[1:]], axis=1)
lcx = LineCollection(segments, array=yp, linewidths=lw, cmap=cmap)
lines.append(lcx)
ax2.add_collection(lcx)
ax2.set_xlim(yp.min(), yp.max())
ax2.set_ylim(xp.min()-.5, xp.max()+.5)
ax2.invert_xaxis()
if ax3.yaxis_inverted():
ax2.invert_yaxis()
ax2.axis('off')
## draw colorbar
sca(ax3)
cb = None
if show_colorbar:
if nrow > 1:
axes = [ax1, ax2, ax3]
while None in axes:
axes.remove(None)
s = H / (H + 1.)
cb = colorbar(mappable=im, ax=axes, anchor=(0, 0), shrink=s, extend=cb_extend)
else:
cb = colorbar(mappable=im, extend=cb_extend)
sca(ax3)
sci(im)
if interactive:
from prody.utilities import ImageCursor
from matplotlib.pyplot import connect
cursor = ImageCursor(ax3, im)
connect('button_press_event', cursor.onClick)
ax3.tick_params(axis='x', rotation=xtickrotation)
return im, lines, cb
