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