def graficoEnElTiempo(self, doc_count, key, filename):
# Fixing random state for reproducibility
np.random.seed(19680801)
# create random data
xdata1 = doc_count
xdata2 = key
# sort the data so it makes clean curves
xdata1.sort()
xdata2.sort()
# create some y data points
##ydata1 = xdata1 ** 2
##ydata2 = 1 - xdata2 ** 3
# plot the data
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.plot(xdata1, color='tab:blue')
ax.plot(xdata2, color='tab:orange')
# create the events marking the x data points
xevents1 = EventCollection(xdata1, color='tab:blue', linelength=0.05)
xevents2 = EventCollection(xdata2, color='tab:orange', linelength=0.05)
# create the events marking the y data points
#yevents1 = EventCollection(ydata1, color='tab:blue', linelength=0.05,
orientation='vertical')
#yevents2 = EventCollection(ydata2, color='tab:orange', linelength=0.05,
orientation='vertical')
def event_collection_1():
# Fixing random state for reproducibility
np.random.seed(19680801)
# create random data
xdata = np.random.random([2, 10])
# split the data into two parts
xdata1 = xdata[0, :]
xdata2 = xdata[1, :]
# sort the data so it makes clean curves
xdata1.sort()
xdata2.sort()
# create some y data points
ydata1 = xdata1 ** 2
ydata2 = 1 - xdata2 ** 3
# plot the data
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.plot(xdata1, ydata1, color='tab:blue')
ax.plot(xdata2, ydata2, color='tab:orange')
# create the events marking the x data points
xevents1 = EventCollection(xdata1, color='tab:blue', linelength=0.05)
xevents2 = EventCollection(xdata2, color='tab:orange', linelength=0.05)
# create the events marking the y data points
yevents1 = EventCollection(
ydata1,
color='tab:blue',
linelength=0.05,
orientation='vertical'
)
yevents2 = EventCollection(
ydata2,
color='tab:orange',
linelength=0.05,
orientation='vertical'
)
# add the events to the axis
ax.add_collection(xevents1)
ax.add_collection(xevents2)
ax.add_collection(yevents1)
ax.add_collection(yevents2)
# set the limits
ax.set_xlim([0, 1])
ax.set_ylim([0, 1])
ax.set_title('line plot with data points')
# display the plot
plt.show()
def generate_matplotlib_pdf(uid, tag, units, digest, summary, frame_count):
# Generate x/y points
x = []
y = []
left = q_graph_min * q_graph_scalar
right = q_graph_max * q_graph_scalar
step = (right - left) * 0.01
for q in range(int(left), int(right + step), int(step)):
pct = q / q_graph_scalar
x.append(pct)
y.append(digest.quantile(pct))
# Generate x event points
xevents = []
t = 0
for c in digest.centroids:
t += weight(c)
xevents.append(t / digest.total_weight)
# Draw the plot
fig = plt.figure()
ax = fig.add_subplot()
ax.set_title('{} PDF'.format(to_pretty_name(tag)))
ax.set_xlabel('Probability Distribution')
ax.set_xlim([0, 1])
ax.set_ylabel('{} - {}'.format(to_pretty_name(tag), units))
ax.plot(x, y)
event_length = (y[-1] - y[0]) / 20
ax.add_collection(
EventCollection(xevents,
lineoffset=y[0] - event_length,
linelength=event_length))
# Use the graph to determine text placement
if digest.quantile(.5) > get_midpoint(digest):
x_txt, y_txt = 0.65, 0.07
else:
x_txt, y_txt = 0.05, 0.7
ax.text(x_txt,
y_txt,
to_text_string(summary, frame_count),
transform=ax.transAxes,
fontsize=14,
verticalalignment='bottom',
horizontalalignment='left',
bbox=dict(boxstyle='round', facecolor='aliceblue', alpha=0.5))
fig.savefig('{}-{}-pdf.png'.format(uid, tag))
def generate_matplotlib_cdf(uid, tag, units, digest, summary, frame_count):
# Generate x/y points
x = []
y = []
left = digest.quantile(q_graph_min)
right = digest.quantile(q_graph_max)
step = (right - left) * 0.01
for w in range(int(left), int(right + step), int(step)):
x.append(w)
y.append(digest.cdf(w))
xevents = [mean(c) for c in digest.centroids]
# Draw the plot
fig = plt.figure()
ax = fig.add_subplot()
ax.set_title('{} CDF'.format(to_pretty_name(tag)))
ax.set_ylabel('Cumulative Density')
ax.set_ylim([0, 1])
ax.set_xlabel('{} - {}'.format(to_pretty_name(tag), units))
ax.plot(x, y)
ax.add_collection(EventCollection(xevents, linelength=0.05))
# Use the graph to determine text placement
if digest.quantile(.5) < get_midpoint(digest):
x_txt, y_txt = 0.65, 0.07
else:
x_txt, y_txt = 0.05, 0.7
ax.text(x_txt,
y_txt,
to_text_string(summary, frame_count),
transform=ax.transAxes,
fontsize=14,
verticalalignment='bottom',
horizontalalignment='left',
bbox=dict(boxstyle='round', facecolor='aliceblue', alpha=0.5))
fig.savefig('{}-{}-cdf.png'.format(uid, tag))
def generate_EventCollection_plot():
'''
generate the initial collection and plot it
'''
positions = np.array([0., 1., 2., 3., 5., 8., 13., 21.])
extra_positions = np.array([34., 55., 89.])
orientation = 'horizontal'
lineoffset = 1
linelength = .5
linewidth = 2
color = [1, 0, 0, 1]
linestyle = 'solid'
antialiased = True
coll = EventCollection(positions,
orientation=orientation,
lineoffset=lineoffset,
linelength=linelength,
linewidth=linewidth,
color=color,
linestyle=linestyle,
antialiased=antialiased)
fig = plt.figure()
splt = fig.add_subplot(1, 1, 1)
splt.add_collection(coll)
splt.set_title('EventCollection: default')
props = {
'positions': positions,
'extra_positions': extra_positions,
'orientation': orientation,
'lineoffset': lineoffset,
'linelength': linelength,
'linewidth': linewidth,
'color': color,
'linestyle': linestyle,
'antialiased': antialiased
}
splt.set_xlim(-1, 22)
splt.set_ylim(0, 2)
return splt, coll, props
xdata1 = xdata[0, :]
xdata2 = xdata[1, :]
xdata1.sort()
xdata2.sort()
ydata1 = xdata1**2
ydata2 = 1 - xdata2**3
fig = plt.figure()
fig.suptitle("line plot with data points")
ax = fig.add_subplot(1, 1, 1)
ax.plot(xdata1, ydata2, 'r', xdata2, ydata2, 'b')
xevents1 = EventCollection(xdata1, color=[1, 0, 0], linelength=0.05)
xevents2 = EventCollection(xdata2, color=[0, 0, 1], linelength=0.05)
yevents1 = EventCollection(ydata1,
color=[1, 0, 0],
linelength=0.05,
orientation='vertical')
yevents2 = EventCollection(ydata2,
color=[0, 0, 1],
linelength=0.05,
orientation='vertical')
ax.add_collection(xevents1)
ax.add_collection(xevents2)
ax.add_collection(yevents1)
ax.add_collection(yevents2)
def test_EventCollection_nosort():
# Check that EventCollection doesn't modify input in place
arr = np.array([3, 2, 1, 10])
coll = EventCollection(arr)
np.testing.assert_array_equal(arr, np.array([3, 2, 1, 10]))
def scatter(self, x, y, xfunc=None, yfunc=None, xscale=None, yscale=None,
xlab=None, ylab=None, genes_to_highlight=None,
label_genes=False, marginal_histograms=False,
general_kwargs=dict(color="k", alpha=0.2, linewidths=0),
general_hist_kwargs=None,
offset_kwargs={}, label_kwargs=None, ax=None,
one_to_one=None, callback=None, xlab_prefix=None,
ylab_prefix=None, sizefunc=None, hist_size=0.3, hist_pad=0.0,
nan_offset=0.015, pos_offset=0.99, linelength=0.01,
neg_offset=0.005):
"""
Do-it-all method for making annotated scatterplots.
Parameters
----------
x, y : array-like
Variables to plot. Must be names in self.data's DataFrame. For
example, "baseMeanA" and "baseMeanB"
xfunc, yfunc : callable
Functions to apply to `xvar` and `yvar` respectively. Default is
log2; set to None to have no transformation.
xlab, ylab : string
Labels for x and y axes; default is to use function names for
`xfunc` and `yfunc` and variable names `xvar` and `yvar`, e.g.,
"log2(baseMeanA)"
ax : None or Axes object
If `ax=None`, then makes a new fig and returns the Axes object,
otherwise, plots onto `ax`
general_kwargs : dict
Kwargs for matplotlib.scatter; specifies how all points look
genes_to_highlight : list of (index, dict) tuples
Provides lots of control to colors. It is a list of (`ind`,
`kwargs`) tuples, where each `ind` specifies genes to plot with
`kwargs`. Each dictionary updates a copy of `general_kwargs`. If
`genes_to_highlight` has a "name" kwarg, this must be a list that't
the same length as `ind`. It will be used to label the genes in
`ind` using `label_kwargs`.
callback : callable
Function to call upon clicking a point. Default is to print the
gene name, but an example of another useful callback would be
a mini-browser connected to a genomic_signal object from which the
expression data were calculated.
one_to_one : None or dict
If not None, a dictionary of matplotlib.plot kwargs that will be
used to plot a 1:1 line.
label_kwargs : dict
Kwargs for labeled genes (e.g., dict=(style='italic')). Will only
be used if an entry in `genes_to_highlight` has a `name` key.
offset_kwargs : dict
Kwargs to be passed to matplotlib.transforms.offset_copy, used for
adjusting the positioning of gene labels in relation to the actual
point.
xlab_prefix, ylab_prefix : str
Optional label prefix that will be added to the beginning of `xlab`
and/or `ylab`.
hist_size : float
Size of marginal histograms
hist_pad : float
Spacing between marginal histograms
nan_offset, pos_offset, neg_offset : float
Offset, in units of "fraction of axes" for the NaN, +inf, and -inf
"rug plots"
linelength : float
Line length for the rug plots
"""
_x = self.data[x]
_y = self.data[y]
# Construct defaults---------------------------------------------------
def identity(x):
return x.copy()
# Axis label setup
if xlab_prefix is None:
xlab_prefix = ""
if ylab_prefix is None:
ylab_prefix = ""
if xlab is None:
xlab = x
if xfunc is not None:
xlab = xlab_prefix + "%s(%s)" % (xfunc.__name__, str(x))
else:
xlab = xlab_prefix + "%s" % (str(x))
if ylab is None:
ylab = y
if yfunc is not None:
ylab = ylab_prefix + "%s(%s)" % (yfunc.__name__, str(y))
else:
ylab = ylab_prefix + "%s" % (str(y))
if xfunc is None:
xfunc = identity
if yfunc is None:
yfunc = identity
if general_kwargs is None:
general_kwargs = {}
if general_hist_kwargs is None:
general_hist_kwargs = {}
if genes_to_highlight is None:
genes_to_highlight = []
if ax is None:
fig = plt.figure()
ax = fig.add_subplot(111)
if label_kwargs is None:
label_kwargs = dict(horizontalalignment='right',
verticalalignment='center', style='italic',
bbox=dict(facecolor='w', edgecolor='None',
alpha=0.5))
# Clean data ---------------------------------------------------------
xi = xfunc(_x)
yi = yfunc(_y)
# handle inf, -inf, and NaN
x_is_pos_inf = np.isinf(xi) & (xi > 0)
x_is_neg_inf = np.isinf(xi) & (xi < 0)
x_is_nan = np.isnan(xi)
y_is_pos_inf = np.isinf(yi) & (yi > 0)
y_is_neg_inf = np.isinf(yi) & (yi < 0)
y_is_nan = np.isnan(yi)
# Indexes for valid values
x_valid = ~(x_is_pos_inf | x_is_neg_inf | x_is_nan)
y_valid = ~(y_is_pos_inf | y_is_neg_inf | y_is_nan)
gmin = max(xi[x_valid].min(), yi[y_valid].min())
gmax = min(xi[x_valid].max(), yi[y_valid].max())
# Convert any integer indexes into boolean, and create a new list of
# genes to highlight. This handles optional hist kwargs.
allind = np.zeros_like(xi) == 0
_genes_to_highlight = []
for block in genes_to_highlight:
ind = block[0]
if ind.dtype != 'bool':
new_ind = (np.zeros_like(xi) == 0)
new_ind[ind] = True
_genes_to_highlight.append(
tuple([new_ind] + list(block[1:]))
)
else:
if hasattr(ind, 'values'):
ind = ind.values
_genes_to_highlight.append(
tuple([ind] + list(block[1:]))
)
# Remove any genes that will be plotted by genes_to_highlight. This
# avoids double-plotting.
for block in _genes_to_highlight:
ind = block[0]
allind[ind] = False
# Copy over the color and alpha if they're not specified
general_hist_kwargs = plotutils._updatecopy(
orig=general_hist_kwargs, update_with=general_kwargs,
keys=['color', 'alpha'])
# Put the non-highlighted genes at the beginning of _genes_to_highlight
# so we can just iterate over that.
_genes_to_highlight.insert(
0,
(allind, general_kwargs, general_hist_kwargs)
)
# Set up the object that will handle the marginal histograms
self.marginal = plotutils.MarginalHistScatter(
ax, hist_size=hist_size, pad=hist_pad)
# Set up kwargs for x and y rug plots
rug_x_kwargs = dict(
linelength=linelength,
transform=blended_transform_factory(ax.transData, ax.transAxes),
)
rug_y_kwargs = dict(
linelength=linelength,
transform=blended_transform_factory(ax.transAxes, ax.transData),
orientation='vertical',
)
# EventCollection objects need a color as a 3-tuple, so set up
# a converter here.
color_converter = matplotlib.colors.ColorConverter().to_rgb
# Plot the one-to-one line, if kwargs were specified
if one_to_one:
ax.plot([gmin, gmax],
[gmin, gmax],
**one_to_one)
# Plot any specially-highlighted genes, and label if specified
for block in _genes_to_highlight:
ind = block[0]
kwargs = block[1]
if len(block) == 3:
hist_kwargs = block[2]
else:
hist_kwargs = {}
names = kwargs.pop('names', None)
_marginal_histograms = (
kwargs.pop('marginal_histograms', False) or
marginal_histograms)
updated_kwargs = plotutils._updatecopy(
orig=kwargs, update_with=general_kwargs)
updated_hist_kwargs = plotutils._updatecopy(
orig=hist_kwargs, update_with=general_hist_kwargs)
updated_hist_kwargs = plotutils._updatecopy(
orig=updated_hist_kwargs, update_with=kwargs,
keys=['color', 'alpha'], override=True)
xhist_kwargs = updated_kwargs.pop('xhist_kwargs', None)
yhist_kwargs = updated_kwargs.pop('yhist_kwargs', None)
self.marginal.append(
xi[ind & x_valid & y_valid],
yi[ind & x_valid & y_valid],
scatter_kwargs=dict(picker=5, **updated_kwargs),
hist_kwargs=updated_hist_kwargs,
xhist_kwargs=xhist_kwargs,
yhist_kwargs=yhist_kwargs,
marginal_histograms=_marginal_histograms)
coll = self.marginal.scatter_ax.collections[-1]
coll.df = self.data
coll.ind = ind
color = color_converter(updated_kwargs['color'])
rug_x_kwargs['color'] = color
rug_y_kwargs['color'] = color
# Note: if both x and y are not valid, then they will not be on the
# plot.
items = [
# top rug, y is +inf and x is valid
(xi, ind & x_valid & y_is_pos_inf, pos_offset, rug_x_kwargs),
# one of the bottom rugs, where y is NaN
(xi, ind & x_valid & y_is_nan, nan_offset, rug_x_kwargs),
# bottom rug, y is -inf
(xi, ind & x_valid & y_is_neg_inf, neg_offset, rug_x_kwargs),
# right rug, x is +inf
(yi, ind & y_valid & x_is_pos_inf, pos_offset, rug_y_kwargs),
# one of the left rugs; x is NaN
(yi, ind & y_valid & x_is_nan, nan_offset, rug_y_kwargs),
# left rug, x is -inf
(yi, ind & y_valid & x_is_neg_inf, neg_offset, rug_y_kwargs),
]
for values, index, offset, kwargs in items:
coll = EventCollection(
values[index], lineoffset=offset, **kwargs)
coll.df = self.data
coll.ind = index
ax.add_collection(coll)
if names:
transOffset = matplotlib.transforms.offset_copy(
ax.transData, fig=ax.figure, **offset_kwargs)
for xii, yii, name in zip(xi[ind], yi[ind], names):
ax.text(xii,
yii,
name,
transform=transOffset,
**label_kwargs)
# register callback
if callback is not None:
def wrapped_callback(event):
return callback(self._id_callback(event))
else:
def wrapped_callback(event):
return self._default_callback(self._id_callback(event))
ax.figure.canvas.mpl_connect('pick_event', wrapped_callback)
ax.set_xlabel(xlab)
ax.set_ylabel(ylab)
ax.axis('tight')
#ax.axis((xmin - xpad, xmax + xpad, ymin - ypad, ymax + ypad))
return ax
# sort the data so it makes clean curves
xdata1.sort()
xdata2.sort()
# create some y data points
ydata1 = xdata1**2
ydata2 = 1 - xdata2**3
# plot the data
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.plot(xdata1, ydata1, color='tab:blue')
ax.plot(xdata2, ydata2, color='tab:orange')
# create the events marking the x data points
xevents1 = EventCollection(xdata1, color='tab:blue', linelength=0.05)
xevents2 = EventCollection(xdata2, color='tab:orange', linelength=0.05)
# create the events marking the y data points
yevents1 = EventCollection(ydata1,
color='tab:blue',
linelength=0.05,
orientation='vertical')
yevents2 = EventCollection(ydata2,
color='tab:orange',
linelength=0.05,
orientation='vertical')
# add the events to the axis
ax.add_collection(xevents1)
ax.add_collection(xevents2)
def scatter(self,
x,
y,
xfunc=None,
yfunc=None,
xscale=None,
yscale=None,
xlab=None,
ylab=None,
genes_to_highlight=None,
label_genes=False,
marginal_histograms=False,
general_kwargs=dict(color="k", alpha=0.2, picker=True),
general_hist_kwargs=None,
offset_kwargs={},
label_kwargs=None,
ax=None,
one_to_one=None,
callback=None,
xlab_prefix=None,
ylab_prefix=None,
sizefunc=None,
hist_size=0.3,
hist_pad=0.0,
nan_offset=0.015,
pos_offset=0.99,
linelength=0.01,
neg_offset=0.005,
figure_kwargs=None):
"""
Do-it-all method for making annotated scatterplots.
Parameters
----------
x, y : array-like
Variables to plot. Must be names in self.data's DataFrame. For
example, "baseMeanA" and "baseMeanB"
xfunc, yfunc : callable
Functions to apply to `xvar` and `yvar` respectively. Default is
log2; set to None to have no transformation.
xlab, ylab : string
Labels for x and y axes; default is to use function names for
`xfunc` and `yfunc` and variable names `xvar` and `yvar`, e.g.,
"log2(baseMeanA)"
ax : None or Axes object
If `ax=None`, then makes a new fig and returns the Axes object,
otherwise, plots onto `ax`
general_kwargs : dict
Kwargs for matplotlib.scatter; specifies how all points look
genes_to_highlight : list of (index, dict) tuples
Provides lots of control to colors. It is a list of (`ind`,
`kwargs`) tuples, where each `ind` specifies genes to plot with
`kwargs`. Each dictionary updates a copy of `general_kwargs`. If
`genes_to_highlight` has a "name" kwarg, this must be a list that't
the same length as `ind`. It will be used to label the genes in
`ind` using `label_kwargs`.
callback : callable
Function to call upon clicking a point. Must accept a single
argument which is the gene ID. Default is to print the gene name,
but an example of another useful callback would be a mini-browser
connected to a genomic_signal object from which the expression data
were calculated.
one_to_one : None or dict
If not None, a dictionary of matplotlib.plot kwargs that will be
used to plot a 1:1 line.
label_kwargs : dict
Kwargs for labeled genes (e.g., dict=(style='italic')). Will only
be used if an entry in `genes_to_highlight` has a `name` key.
offset_kwargs : dict
Kwargs to be passed to matplotlib.transforms.offset_copy, used for
adjusting the positioning of gene labels in relation to the actual
point.
xlab_prefix, ylab_prefix : str
Optional label prefix that will be added to the beginning of `xlab`
and/or `ylab`.
hist_size : float
Size of marginal histograms
hist_pad : float
Spacing between marginal histograms
nan_offset, pos_offset, neg_offset : float
Offset, in units of "fraction of axes" for the NaN, +inf, and -inf
"rug plots"
linelength : float
Line length for the rug plots
"""
_x = self.data[x]
_y = self.data[y]
# Construct defaults---------------------------------------------------
def identity(x):
return x.copy()
# Axis label setup
if xlab_prefix is None:
xlab_prefix = ""
if ylab_prefix is None:
ylab_prefix = ""
if xlab is None:
xlab = x
if xfunc is not None:
xlab = xlab_prefix + "%s(%s)" % (xfunc.__name__, str(x))
else:
xlab = xlab_prefix + "%s" % (str(x))
if ylab is None:
ylab = y
if yfunc is not None:
ylab = ylab_prefix + "%s(%s)" % (yfunc.__name__, str(y))
else:
ylab = ylab_prefix + "%s" % (str(y))
if xfunc is None:
xfunc = identity
if yfunc is None:
yfunc = identity
if general_kwargs is None:
general_kwargs = {}
if general_hist_kwargs is None:
general_hist_kwargs = {}
if genes_to_highlight is None:
genes_to_highlight = []
if ax is None:
if figure_kwargs is None:
figure_kwargs = {}
fig = plt.figure(**figure_kwargs)
ax = fig.add_subplot(111)
if label_kwargs is None:
label_kwargs = dict(horizontalalignment='right',
verticalalignment='center',
style='italic',
bbox=dict(facecolor='w',
edgecolor='None',
alpha=0.5))
# Clean data ---------------------------------------------------------
xi = xfunc(_x)
yi = yfunc(_y)
# handle inf, -inf, and NaN
x_is_pos_inf = np.isinf(xi) & (xi > 0)
x_is_neg_inf = np.isinf(xi) & (xi < 0)
x_is_nan = np.isnan(xi)
y_is_pos_inf = np.isinf(yi) & (yi > 0)
y_is_neg_inf = np.isinf(yi) & (yi < 0)
y_is_nan = np.isnan(yi)
# Indexes for valid values
x_valid = ~(x_is_pos_inf | x_is_neg_inf | x_is_nan)
y_valid = ~(y_is_pos_inf | y_is_neg_inf | y_is_nan)
# global min/max
gmin = max(xi[x_valid].min(), yi[y_valid].min())
gmax = min(xi[x_valid].max(), yi[y_valid].max())
# Convert any integer indexes into boolean, and create a new list of
# genes to highlight. This handles optional hist kwargs.
# We'll compile a new list of genes to highlight.
_genes_to_highlight = []
for block in genes_to_highlight:
ind = block[0]
# Convert to boolean
if ind.dtype != 'bool':
new_ind = (np.zeros_like(xi) == 0)
new_ind[ind] = True
_genes_to_highlight.append(tuple([new_ind] + list(block[1:])))
# If it's a DataFrame, we only want the boolean values;
else:
if hasattr(ind, 'values'):
ind = ind.values
_genes_to_highlight.append(tuple([ind] + list(block[1:])))
# Now we remove any genes from in allind (which will be plotted using
# `general_kwargs`) that will be plotted by genes_to_highlight. This
# avoids double-plotting.
allind = np.zeros_like(xi) == 0
for block in _genes_to_highlight:
ind = block[0]
allind[ind] = False
# Copy over the color and alpha if they're not specified
general_hist_kwargs = plotutils._updatecopy(orig=general_hist_kwargs,
update_with=general_kwargs,
keys=['color', 'alpha'])
# Put the non-highlighted genes at the beginning of _genes_to_highlight
# list so we can just iterate over one list
_genes_to_highlight.insert(
0, (allind, general_kwargs, general_hist_kwargs))
# Set up the object that will handle the marginal histograms
self.marginal = plotutils.MarginalHistScatter(ax,
hist_size=hist_size,
pad=hist_pad)
# Set up kwargs for x and y rug plots
rug_x_kwargs = dict(
linelength=linelength,
transform=blended_transform_factory(ax.transData, ax.transAxes),
)
rug_y_kwargs = dict(
linelength=linelength,
transform=blended_transform_factory(ax.transAxes, ax.transData),
orientation='vertical',
)
# EventCollection objects need a color as a 3-tuple, so set up
# a converter here.
color_converter = matplotlib.colors.ColorConverter().to_rgb
# Plot the one-to-one line, if kwargs were specified
if one_to_one:
ax.plot([gmin, gmax], [gmin, gmax], **one_to_one)
# Plot 'em all, and label if specified
# In order to avoid calling the callback function multiple times when
# we have overlapping genes to highlight (e.g., a gene that is both
# upregulated AND has a peak), keep track of everything that's been
# added so far.
self._seen = np.ones_like(xi) == 0
for block in _genes_to_highlight:
ind = block[0]
kwargs = block[1]
if len(block) == 3:
hist_kwargs = block[2]
else:
hist_kwargs = {}
names = kwargs.pop('names', None)
_marginal_histograms = (kwargs.pop('marginal_histograms', False)
or marginal_histograms)
updated_kwargs = plotutils._updatecopy(orig=kwargs,
update_with=general_kwargs)
updated_hist_kwargs = plotutils._updatecopy(
orig=hist_kwargs, update_with=general_hist_kwargs)
updated_hist_kwargs = plotutils._updatecopy(
orig=updated_hist_kwargs,
update_with=kwargs,
keys=['color', 'alpha'],
override=True)
xhist_kwargs = updated_kwargs.pop('xhist_kwargs', None)
yhist_kwargs = updated_kwargs.pop('yhist_kwargs', None)
self.marginal.append(
xi[ind & x_valid & y_valid],
yi[ind & x_valid & y_valid],
scatter_kwargs=dict(**updated_kwargs),
hist_kwargs=updated_hist_kwargs,
xhist_kwargs=xhist_kwargs,
yhist_kwargs=yhist_kwargs,
marginal_histograms=_marginal_histograms,
)
# This is important for callbacks: here we grab the last-created
# collection,
coll = self.marginal.scatter_ax.collections[-1]
coll.df = self.data
coll.ind = ind & x_valid & y_valid
color = color_converter(updated_kwargs['color'])
rug_x_kwargs['color'] = color
rug_y_kwargs['color'] = color
# Note: if both x and y are not valid, then they will not be on the
# plot.
items = [
# top rug, y is +inf and x is valid
(xi, ind & x_valid & y_is_pos_inf, pos_offset, rug_x_kwargs),
# one of the bottom rugs, where y is NaN
(xi, ind & x_valid & y_is_nan, nan_offset, rug_x_kwargs),
# bottom rug, y is -inf
(xi, ind & x_valid & y_is_neg_inf, neg_offset, rug_x_kwargs),
# right rug, x is +inf
(yi, ind & y_valid & x_is_pos_inf, pos_offset, rug_y_kwargs),
# one of the left rugs; x is NaN
(yi, ind & y_valid & x_is_nan, nan_offset, rug_y_kwargs),
# left rug, x is -inf
(yi, ind & y_valid & x_is_neg_inf, neg_offset, rug_y_kwargs),
]
for values, index, offset, kwargs in items:
coll = EventCollection(values[index],
lineoffset=offset,
**kwargs)
coll.df = self.data
coll.ind = index
ax.add_collection(coll)
if names:
transOffset = matplotlib.transforms.offset_copy(
ax.transData, fig=ax.figure, **offset_kwargs)
for xii, yii, name in zip(xi[ind], yi[ind], names):
ax.text(xii,
yii,
name,
transform=transOffset,
**label_kwargs)
# register callback
if callback is None:
callback = self._default_callback
def wrapped_callback(event):
for _id in self._id_callback(event):
callback(_id)
ax.figure.canvas.mpl_connect('pick_event', wrapped_callback)
ax.set_xlabel(xlab)
ax.set_ylabel(ylab)
ax.axis('tight')
return ax
def animate(self):
"""
calling routine for audio, FFT, peak and partials and key finding, and plotting. Listens for events in plot
window
:return:
string
return code
"""
_firstplot = True
plt.ion() # Stop matplotlib windows from blocking
# start Recording
self.stream.start_stream()
while self.stream.is_active():
_start = timeit.default_timer()
logging.info('Started Audio Stream ...')
time.sleep(self.record_seconds)
self.stream.stop_stream(
) # stop the input stream for the time being
logging.info('Stopped Audio Stream ...')
# Convert the list of numpy-arrays into a 1D array (column-wise)
amp = np.hstack(self.callback_output)
# clear input stream
self.callback_output = []
# interrupt on hotkey 'ctrl-x' and resume on 'esc'
if self.rc == 'x':
while self.rc != 'esc': # loop and wait until ESC ist pressed
time.sleep(.1)
self.rc = None
self.stream.start_stream()
logging.info('Dump last audio stream ...')
continue
elif self.rc == 'y':
return self.rc
_stop = timeit.default_timer()
logging.debug("time utilized for Audio [s]: " +
str(_stop - _start))
logging.info('Analyzing ...')
samples = len(amp)
logging.info('Number of samples: ' + str(samples))
t = np.arange(samples) / parameters.RATE
resolution = parameters.RATE / samples
logging.info('Resolution (Hz/channel): ' + str(resolution))
# calculate FFT
t1, yfft = fft(amp=amp)
# peakfinding
peaks = peak(frequency=t1, spectrum=yfft)
peaklist = list(map(itemgetter(0), peaks))
if peaks is not None:
f_measured = harmonics(peaks=peaks) # find the key
displayed_text = ""
color = 'none'
if len(
f_measured
) != 0: # if key is found print it and its offset colored red or green
tone, displaced = self.find(f_measured=f_measured[0])
if tone:
displayed_text = "{2:s} (a1={3:3.0f}Hz) {0:s} offset={1:.0f} cent"\
.format(tone, displaced, self.tuning, self.a1)
color = 'green' if displaced >= 0 else 'red'
_start = timeit.default_timer()
"""
https://stackoverflow.com/questions/40126176/fast-live-plotting-in-matplotlib-pyplot
"""
if _firstplot: # instantiate first plot and copy background
# Setup figure, axis, lines, text and initiate plot once and copy background
fig = plt.gcf()
ax = fig.add_subplot(211)
ax1 = fig.add_subplot(212)
fig.set_size_inches(12, 8)
ln, = ax.plot(t, amp)
ln1, = ax1.plot(t1, yfft)
text = ax1.text(
self.fmax,
np.max(yfft),
"",
# color='',
verticalalignment='top',
horizontalalignment='right',
fontsize=11,
fontweight='bold')
ax.set_xlabel('Time/s')
ax.set_ylabel('Intensity/arb. units')
ax1.set_xlabel('Frequency/Hz')
ax1.set_ylabel('Intensity/arb. units')
axbackground = fig.canvas.copy_from_bbox(ax.bbox)
ax1background = fig.canvas.copy_from_bbox(ax1.bbox)
else:
# upper subplot
ln.set_xdata(t)
ln.set_ydata(amp)
# lower subplot
ln1.set_xdata(t1)
ln1.set_ydata(yfft)
ax.set_xlim([0., np.max(t)])
ax1.set_xlim([0., self.fmax])
# set text attributes of lower subplot
text.set_text(displayed_text)
text.set_color(color)
text.set_x(self.fmax)
text.set_y(np.max(yfft))
# remove all collections: beginning from last object
while ax1.collections:
ax1.collections.pop()
yevents = EventCollection(positions=peaklist,
color='tab:orange',
linelength=0.05 * np.max(yfft),
linewidth=2.)
ax1.add_collection(yevents)
yevents1 = EventCollection(positions=f_measured,
color='tab:red',
linelength=0.05 * np.max(yfft),
lineoffset=-0.04 * np.max(yfft),
linewidth=2.)
ax1.add_collection(yevents1)
# Rescale the axis so that the data can be seen in the plot
# if you know the bounds of your data you could just set this once
# so that the axis don't keep changing
ax.relim()
ax.autoscale_view()
ax1.relim()
ax1.autoscale_view()
if _firstplot:
plt.pause(0.001)
# fig.canvas.draw()
_firstplot = False
else:
# restore background
fig.canvas.restore_region(axbackground)
fig.canvas.restore_region(ax1background)
# redraw just the points
ax.draw_artist(ln)
ax1.draw_artist(ln1)
ax1.draw_artist(text)
# fill in the axes rectangle
fig.canvas.blit(ax.bbox)
fig.canvas.blit(ax1.bbox)
ax.set_visible(self.visible)
fig.canvas.flush_events()
# resume the audio streaming, expect some retardation for the status change
self.stream.start_stream()
_stop = timeit.default_timer()
logging.debug("time utilized for matplotlib [s]: " +
str(_stop - _start))
return self.rc
def makePDF(name="name",
nVertices="nVertices",
nEdges="nEdges",
maxValency="maxValency",
avgValency="avgValency",
curve="curve",
diameter="not computed"):
print(" * Building PDF report")
import matplotlib.pyplot as plt
from matplotlib.collections import EventCollection
import io
import base64
# plot the data
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.plot(curve['x'], curve['y'], color='tab:red')
xevents1 = EventCollection(curve['x'], color='tab:blue', linelength=0.5)
yevents1 = EventCollection(curve['y'],
color='tab:blue',
linelength=0.5,
orientation='vertical')
# add the events to the axis
ax.add_collection(xevents1)
ax.add_collection(yevents1)
if not diameter:
diameter = "not computed"
# set the limits
ax.set_xlim([0, maxValency + 1])
ax.set_ylim([0, max(curve['y']) + 5])
ax.set_title('Distribution des degrés')
plt.xlabel('Degré')
plt.ylabel('Frequence d\'apparition (%)')
# display the plot
# plt.show()
my_stringIObytes = io.BytesIO()
plt.savefig(my_stringIObytes, format='jpg')
my_stringIObytes.seek(0)
my_base64_jpgData = base64.b64encode(my_stringIObytes.read())
with open('template/index.html') as template:
report_html = template.read().replace('\n', '').replace(
'\t', '').format(image=my_base64_jpgData,
caption='Salut',
width=600,
height=400,
name=name,
nVertices=nVertices,
nEdges=nEdges,
maxValency=maxValency,
avgValency=avgValency,
diameter=diameter)
convert_html_to_pdf(report_html, name + '-report.pdf')
return "report-2.pdf"
# costLabels = numpy.array(costLabels)
# xdata = costLabels[:, 0]
# ydata = costLabels[:, 1]
costLabels = numpy.array(costLabels)
xdata = costLabels[:, 0]
ydata = costLabels[:, 1]
# plot the data
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.plot(xdata, ydata, color='tab:blue')
# create the events marking the x data points
xevents = EventCollection(xdata, color='tab:blue', linelength=0.03)
# create the events marking the y data points
yevents = EventCollection(ydata, color='tab:blue', linelength=0.03,
orientation='vertical')
# add the events to the axis
ax.add_collection(xevents)
ax.add_collection(yevents)
# set the limits
ax.set_xlim([0, epoch_num])
ax.set_ylim([0, 5])
ax.set_title('line plot with data points')
# Data set for the field/column.
print(" len(simulation_results_database[current_field_name]):",
len(simulation_results_database[current_field_name]), ".")
#print(": simulation_results_database[current_field_name]:",simulation_results_database[current_field_name],".")
print(" current color:", enumerated_color, ".")
"""
Plot currently enumerated field (i.e., V_in or V_out)
on the y-axis against time column/field on the x-axis.
"""
ax.plot(simulation_results_database[temp_list_column_headers[1]],
simulation_results_database[current_field_name],
color=enumerated_color)
#xevents1 = EventCollection(simulation_results_database[temp_list_column_headers[1]], color=enumerated_color, linelength=0.05)
yevents1 = EventCollection(
simulation_results_database[current_field_name],
color=enumerated_color,
linelength=0.05,
orientation='vertical')
#ax.add_collection(xevents1)
ax.add_collection(yevents1)
"""
ax.plot(temp_list_column_headers[1], ydata1, color='tab:blue')
xevents1 = EventCollection(xdata1, color='tab:blue', linelength=0.05)
yevents1 = EventCollection(ydata1, color='tab:blue', linelength=0.05, orientation='vertical')
ax.add_collection(xevents1)
ax.add_collection(yevents1)
ax.plot(xdata2, ydata2, color='tab:orange')
xevents2 = EventCollection(xdata2, color='tab:orange', linelength=0.05)
yevents2 = EventCollection(ydata2, color='tab:orange', linelength=0.05, orientation='vertical')
ax.add_collection(xevents2)
ax.add_collection(yevents2)
def generate_graph():
'''
Method which is used to draw graph via matplot library
:return:
'''
file = open(
'A:\\_MACIEK\\WORK\\Develop\\Metaheuristic\\sum_of_subset\\data\\output\\stats_to_graph.csv',
'rt')
data = csv.reader(file, delimiter=' ')
time_brut = []
time_climb = []
time_simu = []
time_tabu = []
size_brut = []
size_climb = []
size_simu = []
size_tabu = []
for line in data:
if str(line[0]) == 'Brut':
size_brut.append(int(line[1]))
time_brut.append(float(line[4]))
elif str(line[0]) == 'Clim':
size_climb.append(int(line[1]))
time_climb.append(float(line[4]))
elif str(line[0]) == 'Simu':
size_simu.append(int(line[1]))
time_simu.append(float(line[4]))
elif str(line[0]) == 'Tabu':
size_tabu.append(int(line[1]))
time_tabu.append(float(line[4]))
xdata1 = size_brut[:]
ydata1 = time_brut[:]
xdata2 = size_climb[:]
ydata2 = time_climb[:]
xdata3 = size_simu[:]
ydata3 = time_simu[:]
xdata4 = size_tabu[:]
ydata4 = time_tabu[:]
xdata1.sort()
ydata1.sort()
xdata2.sort()
ydata2.sort()
xdata3.sort()
ydata3.sort()
xdata4.sort()
ydata4.sort()
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.plot(xdata1, ydata1, color='tab:blue', label='Bruteforce')
ax.plot(xdata2, ydata2, color='tab:green', label='Climbing')
ax.plot(xdata3, ydata3, color='tab:orange', label='Simulated-Annealing')
ax.plot(xdata4, ydata4, color='tab:red', label='Tabu')
xevents1 = EventCollection(xdata1,
color='tab:blue',
linelength=0.05,
orientation='vertical')
xevents2 = EventCollection(xdata2,
color='tab:green',
linelength=0.05,
orientation='vertical')
xevents3 = EventCollection(xdata3,
color='tab:orange',
linelength=0.05,
orientation='vertical')
xevents4 = EventCollection(xdata4,
color='tab:red',
linelength=0.05,
orientation='vertical')
yevents1 = EventCollection(ydata1,
color='tab:blue',
linelength=0.05,
orientation='vertical')
yevents2 = EventCollection(ydata2,
color='tab:green',
linelength=0.05,
orientation='vertical')
yevents3 = EventCollection(ydata3,
color='tab:orange',
linelength=0.05,
orientation='vertical')
yevents4 = EventCollection(ydata4,
color='tab:red',
linelength=0.05,
orientation='vertical')
ax.add_collection(xevents1)
ax.add_collection(xevents2)
ax.add_collection(xevents3)
ax.add_collection(xevents4)
ax.add_collection(yevents1)
ax.add_collection(yevents2)
ax.add_collection(yevents3)
ax.add_collection(yevents4)
ax.set_xlim([10, 20])
ax.set_ylim([0, 1])
ax.legend()
ax.set_title('Graph of estimated time of generated solution')
plt.show()
