def makeHDPlot(self, spk_times: np.array = None,
ax: matplotlib.axes = None, **kwargs) -> matplotlib.axes:
self.initialise()
spk_times_in_pos_samples = self.getSpikePosIndices(spk_times)
spk_weights = np.bincount(
spk_times_in_pos_samples, minlength=self.npos)
rmap = self.RateMapMaker.getMap(spk_weights, 'dir')
if ax is None:
fig = plt.figure()
ax = fig.add_subplot(111, projection='polar')
# need to deal with the case where the axis is supplied but
# is not polar. deal with polar first
theta = np.deg2rad(rmap[1][0])
ax.clear()
r = rmap[0]
r = np.insert(r, -1, r[0])
if 'polar' in ax.name:
ax.plot(theta, r)
if 'fill' in kwargs:
ax.fill(theta, r, alpha=0.5)
ax.set_aspect('equal')
else:
pass
# See if we should add the mean resultant vector (mrv)
if 'add_mrv' in kwargs:
from ephysiopy.common.statscalcs import mean_resultant_vector
angles = self.dir[spk_times_in_pos_samples]
r, th = mean_resultant_vector(np.deg2rad(angles))
ax.plot([th, th], [0, r*np.max(rmap[0])], 'r')
if 'polar' in ax.name:
ax.set_thetagrids([0, 90, 180, 270])
return ax
def makePowerSpectrum(
self, freqs: np.array, power: np.array, sm_power: np.array,
band_max_power: float, freq_at_band_max_power: float,
max_freq: int = 50, theta_range: tuple = [6, 12],
ax: matplotlib.axes = None, **kwargs) -> matplotlib.axes:
# downsample frequencies and power
freqs = freqs[0::50]
power = power[0::50]
sm_power = sm_power[0::50]
if ax is None:
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(freqs, power, alpha=0.5, color=[0.8627, 0.8627, 0.8627])
ax.plot(freqs, sm_power)
ax.set_xlim(0, max_freq)
ylim = [0, band_max_power / 0.8]
if 'ylim' in kwargs:
ylim = kwargs['ylim']
ax.set_ylim(ylim)
ax.set_ylabel('Power')
ax.set_xlabel('Frequency')
ax.text(
x=theta_range[1] / 0.9, y=band_max_power,
s=str(freq_at_band_max_power)[0:4], fontsize=20)
from matplotlib.patches import Rectangle
r = Rectangle((
theta_range[0], 0), width=np.diff(theta_range)[0],
height=np.diff(ax.get_ylim())[0], alpha=0.25, color='r', ec='none')
ax.add_patch(r)
return ax
def plotPRITransformVal(ax: axes,
bins: np.array,
vals: np.array,
title: str = None,
plot_ylabel: bool = False) -> None:
ax.plot(bins, vals, linewidth=2)
ax.set_title(title, fontsize=10)
ax.set_xlabel('pri[us]', fontsize=8, loc='right')
if plot_ylabel:
ax.set_ylabel('interval values', fontsize=10)
def makeSpikePathPlot(self, spk_times: np.array = None,
ax: matplotlib.axes = None,
**kwargs) -> matplotlib.axes:
self.initialise()
if 'c' in kwargs:
col = kwargs.pop('c')
else:
col = tcols.colours[1]
if ax is None:
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(self.xy[0, :], self.xy[1, :], c=tcols.colours[0], zorder=1)
ax.set_aspect('equal')
if spk_times is not None:
idx = self.getSpikePosIndices(spk_times)
ax.plot(
self.xy[0, idx], self.xy[1, idx], 's', c=col, **kwargs)
return ax
def plot_openness_by_weekday(data: list, period: dict, ax: Axes):
"""
Plot the openness by weekday from the raw data.
:param data: Raw data
:param period: Period over which to average the openness
:param ax: Axes object in which to put the plot
:return: None
"""
week_bins = get_openness_by_weekday(data, period)
weekday_avg = sum(week_bins[0:5]) / 5
weekend_avg = sum(week_bins[5:7]) / 2
# Plot bar
ax.bar(range(7), week_bins)
# Plot averages
ax.text(
2,
weekday_avg * 1.05,
f"Gjennomsnitt ukedager: {weekday_avg * 100:.0f}{percent()}",
)
ax.text(
4.5,
weekend_avg * 1.1,
f"Gjennomsnitt helgedager: {weekend_avg * 100:.0f}{percent()}",
)
ax.plot((0, 5 - 1), (weekday_avg, weekday_avg), "k--")
ax.plot((5, 7 - 1), (weekend_avg, weekend_avg), "k--")
# Decorate axes
ax.set_xticklabels(
("", "Mandag", "Tirsdag", "Onsdag", "Torsdag", "Fredag", "Lørdag", "Søndag")
)
ax.set_yticklabels(
[f"{openness * 100:.1f}{percent()}" for openness in ax.get_yticks()]
)
ax.set_ylabel("Andel åpen")
def plot_visit_durations(data: list, ax: Axes):
"""
Plot the visit durations from the raw data.
:param data: Raw data
:param ax: Axes object in which to put the plot
:return: None
"""
# Histogram options
min_visit_s = 30
max_visit_s = 60 * 60 * 3
nbins = 150
# Regression line options
fit_start = 6
fit_stop = 144
# Create histogram
durations = get_visit_durations(data)
n, bins, _ = ax.hist(durations, bins=linspace(min_visit_s, max_visit_s, nbins))
# Create regression line
bin_width = (bins[fit_stop - 1] - bins[fit_start]) / (fit_start - fit_stop)
lin_fitting_bins = [b + bin_width / 2 for b in bins[fit_start:fit_stop]]
lin_fitting_n = n[fit_start:fit_stop]
[a, b] = polyfit(lin_fitting_bins, log(lin_fitting_n), 1, w=sqrt(lin_fitting_n))
fitted_n = [exp(b + a * t) for t in lin_fitting_bins]
regression_line_opts = {"linestyle": "--", "color": "black", "linewidth": 2}
regression_label_text = "y={:.0f}exp({:.6f}*t)".format(exp(b), a)
regression_label_coords = (max_visit_s * 0.6, max(n) * 0.5)
ax.plot(lin_fitting_bins, fitted_n, **regression_line_opts)
ax.text(*regression_label_coords, regression_label_text)
# Label axes
ax.set_xlabel("Varighet for visitt (s)")
ax.set_ylabel("Andel visitter (vilkårlig)")
ax.set_yscale("log")
def evolution_of_participation_1D(
data: dict,
ax: mpl.axes,
entity_in_focus: Optional[list] = None,
percentage: bool = False,
colormap: mpl.colors.LinearSegmentedColormap = mpl.cm.jet,
) -> mpl.axes:
"""
Parameters
----------
data : Dictionary with a format {'x_axis_labels': {'y_axis_labels': y_values}}
entity_in_focus :
percentage :
"""
x = list(data.keys())
ylabels = stackedareachart.get_ylabels(data)
y = stackedareachart.data_transformation(data, ylabels, percentage)
colors = utils.create_color_palette(
ylabels,
entity_in_focus,
colormap,
include_dof=False,
return_dict=True,
)
for iy, ylab in enumerate(ylabels):
if ylab in entity_in_focus:
ax.plot(
x,
y[iy, :],
color="w",
linewidth=4,
zorder=1,
)
ax.plot(
x,
y[iy, :],
color=colors[ylab],
linewidth=3,
zorder=1,
label=ylab,
)
else:
ax.plot(
x,
y[iy, :],
color="grey",
linewidth=1,
zorder=0,
alpha=0.2,
)
if np.isfinite(np.max(x)):
ax.set_xlim(np.min(x), np.max(x))
if np.isfinite(np.max(y)):
ax.set_ylim(np.min(y), np.max(y))
return ax
def plot_chromatograph(
seq: SeqRecord, region: Tuple[int, int] = None, ax: mpl.axes = None
) -> plt.axes:
"""Plot Sanger chromatograph.
region: include both start and end (1-based)
"""
if seq is None:
return ax
if region is None:
# turn into 0 based for better indexing
region_start, region_end = 0, len(seq)
else:
region_start = max(region[0], 0)
region_end = min(region[1], len(seq) - 1)
if ax is None:
_, ax = plt.subplots(1, 1, figsize=(16, 6))
_colors = defaultdict(
lambda: "purple", {"A": "g", "C": "b", "G": "k", "T": "r"}
)
# Get signals
peaks = seq.annotations["peak positions"]
trace_x = seq.annotations["trace_x"]
traces_y = [seq.annotations["channel " + str(i)] for i in range(1, 5)]
bases = seq.annotations["channels"]
xlim_left, xlim_right = peaks[region_start] - 1, peaks[region_end] + 0.5
# subset peak and sequence
# TODO: this might fix the bug
peak_start = peaks[0]
peak_zip = [
(p, s)
for i, (p, s) in enumerate(zip(peaks, seq))
if region_start <= i <= region_end
]
peaks, seq = list(zip(*peak_zip))
# subset trace_x and traces_y together
trace_zip = [
(x + peak_start, *ys)
for x, *ys in zip(trace_x, *traces_y)
if xlim_left <= x <= xlim_right
]
if not trace_zip:
return ax
trace_x, *traces_y = list(zip(*trace_zip))
# Plot traces
trmax = max(map(max, traces_y))
for base in bases:
trace_y = [1.0 * ci / trmax for ci in traces_y[bases.index(base)]]
ax.plot(trace_x, trace_y, color=_colors[base], lw=2, label=base)
ax.fill_between(
trace_x, 0, trace_y, facecolor=_colors[base], alpha=0.125
)
# Plot bases at peak positions
for i, peak in enumerate(peaks):
# LOGGER.debug(f"{i}, {peak}, {seq[i]}, {xlim_left + i}")
ax.text(
peak,
-0.11,
seq[i],
color=_colors[seq[i]],
va="center",
ha="center",
alpha=0.66,
fontsize="x-large",
fontweight="bold",
)
ax.set_ylim(bottom=-0.15, top=1.05)
# peaks[0] - max(2, 0.02 * (peaks[-1] - peaks[0])),
# right=peaks[-1] + max(2, 0.02 * (peaks[-1] - peaks[0])),
ax.set_xlim(xlim_left + 0.5, xlim_right)
ax.set_xticks(peaks)
ax.set_xticklabels(list(range(region_start + 1, region_end + 2)))
# hide y axis
ax.set_yticklabels([])
ax.get_yaxis().set_visible(False)
# hide border
ax.spines["left"].set_visible(False)
ax.spines["right"].set_visible(False)
ax.spines["top"].set_visible(False)
# hide grid
ax.grid(False)
# set legend
ax.legend(loc="upper left", bbox_to_anchor=(0.95, 0.99))
return ax
def show_SAC(self, A: np.array, inDict: dict,
ax: matplotlib.axes = None, **kwargs) -> matplotlib.axes:
"""
Displays the result of performing a spatial autocorrelation (SAC)
on a grid cell.
Uses the dictionary containing measures of the grid cell SAC to
make a pretty picture
Parameters
----------
A : array_like
The spatial autocorrelogram
inDict : dict
The dictionary calculated in getmeasures
ax : matplotlib.axes._subplots.AxesSubplot, optional
If given the plot will get drawn in these axes. Default None
Returns
-------
fig : matplotlib.Figure instance
The Figure on which the SAC is shown
See Also
--------
ephysiopy.common.binning.RateMap.autoCorr2D()
ephysiopy.common.ephys_generic.FieldCalcs.getMeaures()
"""
if ax is None:
fig = plt.figure()
ax = fig.add_subplot(111)
Am = A.copy()
Am[~inDict['dist_to_centre']] = np.nan
Am = np.ma.masked_invalid(np.atleast_2d(Am))
x, y = np.meshgrid(
np.arange(0, np.shape(A)[1]),
np.arange(0, np.shape(A)[0]))
vmax = np.nanmax(np.ravel(A))
ax.pcolormesh(
x, y, A, cmap=plt.cm.get_cmap("gray_r"),
edgecolors='face', vmax=vmax, shading='auto')
import copy
cmap = copy.copy(plt.cm.get_cmap("jet"))
cmap.set_bad('w', 0)
ax.pcolormesh(
x, y, Am, cmap=cmap,
edgecolors='face', vmax=vmax, shading='auto')
# horizontal green line at 3 o'clock
_y = (np.shape(A)[0]/2, np.shape(A)[0]/2)
_x = (np.shape(A)[1]/2, np.shape(A)[0])
ax.plot(_x, _y, c='g')
mag = inDict['scale'] * 0.5
th = np.linspace(0, inDict['orientation'], 50)
from ephysiopy.common.utils import rect
[x, y] = rect(mag, th, deg=1)
# angle subtended by orientation
ax.plot(
x + (inDict['dist_to_centre'].shape[1] / 2),
(inDict['dist_to_centre'].shape[0] / 2) - y, 'r', **kwargs)
# plot lines from centre to peaks above middle
for p in inDict['closest_peak_coords']:
if p[0] <= inDict['dist_to_centre'].shape[0] / 2:
ax.plot(
(inDict['dist_to_centre'].shape[1]/2, p[1]),
(inDict['dist_to_centre'].shape[0] / 2, p[0]), 'k', **kwargs)
ax.invert_yaxis()
all_ax = ax.axes
all_ax.set_aspect('equal')
all_ax.set_xlim((0.5, inDict['dist_to_centre'].shape[1]-1.5))
all_ax.set_ylim((inDict['dist_to_centre'].shape[0]-.5, -.5))
return ax
def evolution_of_participation_2D(
xdata: dict,
ydata: dict,
ax: mpl.axes,
entity_in_focus: Optional[list] = None,
percentage: bool = False,
colormap: mpl.colors.LinearSegmentedColormap = mpl.cm.jet,
) -> mpl.axes:
"""
Parameters
----------
data : Dictionary with a format {'x_axis_labels': {'y_axis_labels': y_values}}
entity_in_focus :
percentage :
"""
# TODO: include time indication
xlabels = stackedareachart.get_ylabels(xdata)
ylabels = stackedareachart.get_ylabels(ydata)
# ensure uniform order
labels = list(set(xlabels + ylabels))
xindx = [xlabels.index(lab) if lab in xlabels else None for lab in labels]
xlabels = [xlabels[i] if i is not None else None for i in xindx]
yindx = [ylabels.index(lab) if lab in ylabels else None for lab in labels]
ylabels = [ylabels[i] if i is not None else None for i in yindx]
# create arrays with format (# of ylabels, # of xlabels)
x = stackedareachart.data_transformation(xdata, xlabels, percentage)
y = stackedareachart.data_transformation(ydata, ylabels, percentage)
colors = utils.create_color_palette(
ylabels,
entity_in_focus,
colormap,
include_dof=False,
return_dict=True,
)
ax.plot([0, np.max(y)], [0, np.max(y)], c="k", linestyle="--", zorder=0)
for i, lab in enumerate(labels):
if lab in entity_in_focus:
ax.plot(
x[i, :],
y[i, :],
color="w",
linewidth=4,
zorder=1,
)
ax.plot(
x[i, :],
y[i, :],
color=colors[lab],
linewidth=3,
zorder=1,
label=lab,
)
else:
ax.plot(
x[i, :],
y[i, :],
color="grey",
linewidth=1,
zorder=0,
alpha=0.2,
)
ax.set_xlim(np.min(x), np.max(x))
ax.set_ylim(np.min(y), np.max(y))
return ax
def evolution_of_graph_property_by_domain(
data: dict,
xkey: str,
ykey: str,
ax: mpl.axes,
entity_in_focus: Optional[list] = None,
percentile: Optional[float] = None,
colormap: mpl.colors.LinearSegmentedColormap = mpl.cm.jet,
) -> mpl.axes:
"""
Parameters
----------
data : Dictionary create with
bigbang.analysis.ListservList.get_graph_prop_per_domain_per_year()
ax :
entity_in_focus :
percentile :
"""
colors = utils.create_color_palette(
list(data.keys()),
entity_in_focus,
colormap,
include_dof=False,
return_dict=True,
)
if entity_in_focus:
for key, value in data.items():
if key in entity_in_focus:
ax.plot(
value[xkey],
value[ykey],
color="w",
linewidth=4,
zorder=1,
)
ax.plot(
value[xkey],
value[ykey],
color=colors[key],
linewidth=3,
label=key,
zorder=2,
)
else:
ax.plot(
value[xkey],
value[ykey],
color="grey",
alpha=0.2,
linewidth=1,
zorder=0,
)
if percentile is not None:
betweenness_centrality = []
for key, value in data.items():
betweenness_centrality += value[ykey]
betweenness_centrality = np.array(betweenness_centrality)
threshold = np.percentile(betweenness_centrality, percentile)
for key, value in data.items():
if any(np.array(value[ykey]) > threshold):
ax.plot(
value[xkey],
value[ykey],
color="w",
linewidth=4,
zorder=1,
)
ax.plot(
value[xkey],
value[ykey],
linewidth=3,
color=colors[key],
label=key,
zorder=2,
)
else:
ax.plot(
value[xkey],
value[ykey],
color="grey",
linewidth=1,
alpha=0.2,
zorder=0,
)
return ax
