def _modified_bbox(self, bbox=None): if bbox is None: return Bbox.from_extents(0, -90, 360, 90) else: xmin = bbox.xmin + 360 if bbox.xmin < 0 else bbox.xmin xmax = bbox.xmax + 360 if bbox.xmax < 0 else bbox.xmax return Bbox.from_extents(xmin, bbox.ymin, xmax, bbox.ymax)
def find_selected_axes(canvas, x1, y1, x2, y2): """ Finds the C{Axes} within a matplotlib C{FigureCanvas} that overlaps with a canvas area from C{(x1, y1)} to C{(x1, y1)}. That axes and the corresponding X and Y axes ranges are returned as a 3-tuple. If no axes overlaps with the specified area, or more than one axes overlaps, a 3-tuple of C{None}s is returned. """ axes = None bbox = Bbox.from_extents(x1, y1, x2, y2) for a in canvas.get_figure().get_axes(): if bbox.overlaps(a.bbox): if axes is None: axes = a else: return None, None, None if axes is None: return None, None, None x1, y1, x2, y2 = limit_selection(bbox, axes) xlim, ylim = get_bbox_lims( Bbox.from_extents(x1, y1, x2, y2).inverse_transformed(axes.transData)) return axes, xlim, ylim
def plot(self, *args, **kwargs): ps = self.env.ps myc = self._get_class_config() iter_list = self.config['iter_list'] l, b, r, t = myc['bbox_rect'] gamma_all = np.empty(0) pbumps_all = np.empty(0) # Separate noise sigmas for ns_idx, noise_sigma in enumerate(ps.noise_sigmas): if ns_idx == 0: mi_title = 'Gamma power vs. P_Bumps' else: mi_title = None gammaData = aggr.GammaAggregateData('acVal', ps.bumpGamma[ns_idx], iter_list, normalizeTicks=False, collapseTrials=False) pbumpsData = aggr.IsBump(ps.bumpGamma[ns_idx], iter_list, ignoreNaNs=True, collapseTrials=False) gammaData, _, _ = gammaData.getData() pbumpsData, _, _ = pbumpsData.getData() gamma_all = np.hstack((gamma_all, gammaData.flatten())) pbumps_all = np.hstack((pbumps_all, pbumpsData.flatten())) fig = self._get_final_fig(myc['fig_size']) ax = fig.add_axes(Bbox.from_extents(l, b, r, t)) self.plotDistribution(pbumpsData, gammaData, ax, noise_sigma=noise_sigma, ylabel='', yticks=False) fname = self.config[ 'output_dir'] + "/gamma_pbumps_probability_{0}.pdf" fig.savefig(fname.format(int(noise_sigma)), dpi=300, transparent=True) plt.close(fig) self.mutual_information(gammaData, pbumpsData, noise_sigma=noise_sigma, title=mi_title) # All together fig = self._get_final_fig(myc['fig_size']) ax = fig.add_axes(Bbox.from_extents(l, b, r, t)) self.plotDistribution(pbumps_all, gamma_all, ax) #fig.tight_layout(**myc['tight_layout_kwargs']) fname = self.config['output_dir'] + "/gamma_pbumps_probability_all.pdf" fig.savefig(fname, dpi=300, transparent=True) plt.close(fig) self.mutual_information(gamma_all, pbumps_all)
def generate_arrow(): dpi = 72 dpi2 = dpi / 3 F = plt.figure(num=None, figsize=(0.6, 0.325), dpi=dpi, facecolor='w') ax = plt.subplot(111) x = [0, 1, 1, 0, 0] y = [1, 1, 0, 0, 1] ed = ax.transAxes.transform([(0, 0), (1, 1)]) bbox = Bbox.from_extents((ed[0, 0] + 1) / dpi, (ed[0, 1] + 1) / dpi, ed[1, 0] / dpi, (ed[1, 1] - 2) / dpi) print('### generating arrow palette button ###') a = np.linspace(0, 1, 256).reshape(1, -1) a = np.vstack((a, a)) for name, style in arrowstyle_list(): ax.cla() ax.tick_params(length=0) ax.annotate('', [1, 0.5], xytext=[0, 0.5], arrowprops=dict(arrowstyle=style)) filename = 'arrow_' + encode(name.encode()) + '.png' ed = ax.transAxes.transform([(0, 0), (1, 1)]) bbox = Bbox.from_extents(ed[0, 0] / dpi, ed[0, 1] / dpi, ed[1, 0] / dpi, ed[1, 1] / dpi) plt.savefig(filename, dpi=dpi, format='png', bbox_inches=bbox)
def plotIToEBrokenAxis(sp, gIdx, neuronIdx, trialNum=0, axBoundaries=None, axesProportions=(0.5, 0.5), bottomLimits=None, topLimits=None, **kw): if axBoundaries is None: axBoundaries = [0, 0, 1, 1] left, bottom, right, top = axBoundaries title = kw.pop('title', 'E cell') fig = kw.pop('fig', plt.gcf()) h = top - bottom w = right - left hBottom = h * axesProportions[0] hTop = h * axesProportions[1] axBottom = fig.add_axes( Bbox.from_extents(left, bottom, right, bottom + hBottom)) axTop = fig.add_axes(Bbox.from_extents(left, top - hTop, right, top), sharex=axBottom) _, gI = aggr.computeYX(sp, iterList) M = sp[0][gIdx][trialNum].data['g_EI'] conns = M[neuronIdx, :] pconn.plotConnHistogram(conns, title=title, ax=axBottom, **kw) kw['ylabel'] = '' pconn.plotConnHistogram(conns, title=title, ax=axTop, **kw) annG = gI[0, gIdx] if annG - int(annG) == 0: annG = int(annG) #ann = '$g_I$ = {0} nS'.format(annG) #fig.text(left+0.95*w, bottom+0.9*h, ann, ha='right', va='bottom', # fontsize='x-small') axBottom.set_xlim([0, annG]) axBottom.set_xticks([0, annG]) axBottom.xaxis.set_ticklabels([0, '$g_I$']) axBottom.set_ylim(bottomLimits) axBottom.set_yticks(bottomLimits) axBottom.yaxis.set_minor_locator(ti.NullLocator()) axTop.set_ylim(topLimits) axTop.set_yticks([topLimits[1]]) axTop.xaxis.set_visible(False) axTop.spines['bottom'].set_visible(False) divLen = 0.07 d = .015 kwargs = dict(transform=fig.transFigure, color='k', clip_on=False) axBottom.plot((left - divLen * w, left + divLen * w), (bottom + hBottom + d, bottom + hBottom - d), **kwargs) axTop.plot((left - divLen * w, left + divLen * w), (top - hTop + d, top - hTop - d), **kwargs) return axBottom, axTop
def plot(self, *args, **kwargs): ps = self.env.ps output_dir = self.config['output_dir'] rateLeft = rasterLeft rateBottom = 0.2 rateRight = rasterRight rateTop = self.myc['rateTop'] for idx, noise_sigma in enumerate(ps.noise_sigmas): # E cells fig = self._get_final_fig(self.myc['fig_size']) ax = fig.add_axes( Bbox.from_extents(rateLeft, rateBottom, rateRight, rateTop)) kw = {} if (idx != 0): kw['ylabel'] = '' rasters.plotAvgFiringRate(ps.bumpGamma[idx], spaceType='bump', noise_sigma=ps.noise_sigmas[idx], popType='E', r=rasterRC[idx][0], c=rasterRC[idx][1], ylabelPos=self.myc['ylabelPos'], color='red', tLimits=tLimits, ax=ax, **kw) fname = output_dir + "/bumps_rate_e{0}.pdf".format(noise_sigma) fig.savefig(fname, dpi=300, transparent=transparent) plt.close() # I cells fig = self._get_final_fig(self.myc['fig_size']) ax = fig.add_axes( Bbox.from_extents(rateLeft, rateBottom, rateRight, rateTop)) kw = {} if (idx != 0): kw['ylabel'] = '' rasters.plotAvgFiringRate(ps.bumpGamma[idx], spaceType='bump', noise_sigma=ps.noise_sigmas[idx], popType='I', r=rasterRC[idx][0], c=rasterRC[idx][1], ylabelPos=self.myc['ylabelPos'], color='blue', tLimits=tLimits, ax=ax, **kw) fname = output_dir + "/bumps_rate_i{0}.pdf".format(noise_sigma) fig.savefig(fname, dpi=300, transparent=transparent) plt.close()
def plot(self, *args, **kwargs): ps = self.env.ps output_dir = self.config['output_dir'] transparent = self.myc['transparent'] for idx, noise_sigma in enumerate(ps.noise_sigmas): # E cells fig = self._get_final_fig(self.myc['fig_size']) l, b, r, t = self.myc['bbox'] ax = fig.add_axes(Bbox.from_extents(l, b, r, t)) kw = {} if (idx != 0): kw['ylabel'] = '' rasters.plotAvgFiringRate( ps.v[idx], spaceType='velocity', noise_sigma=noise_sigma, popType='E', r=rasterRC[idx][0], c=rasterRC[idx][1], color='red', ylabelPos=self.config['vel_rasters']['ylabelPos'], tLimits=self.config['vel_rasters']['tLimits'], trialNum=self.config['vel_rasters']['trialNum'], sigmaTitle=False, ax=ax, **kw) fname = output_dir + "/velocity_rate_e{0}.pdf".format(noise_sigma) fig.savefig(fname, dpi=300, transparent=transparent) plt.close() # I cells fig = self._get_final_fig(self.myc['fig_size']) ax = fig.add_axes(Bbox.from_extents(l, b, r, t)) kw = {} if (idx != 0): kw['ylabel'] = '' rasters.plotAvgFiringRate( ps.v[idx], spaceType='velocity', noise_sigma=noise_sigma, popType='I', r=rasterRC[idx][0], c=rasterRC[idx][1], color='blue', ylabelPos=self.config['vel_rasters']['ylabelPos'], tLimits=self.config['vel_rasters']['tLimits'], trialNum=self.config['vel_rasters']['trialNum'], sigmaTitle=False, ax=ax, **kw) fname = output_dir + "/velocity_rate_i{0}.pdf".format(noise_sigma) fig.savefig(fname, dpi=300, transparent=transparent) plt.close()
def zoom_effect(ax_zoomed, ax_origin, xlims = None, orientation='below', **kwargs): """ ax_zoomed : zoomed axes ax_origin: the main axes (xmin,xmax) : the limits of the colored area in both plot axes. connect ax1 & ax2. The x-range of (xmin, xmax) in both axes will be marked. The keywords parameters will be used ti create patches. """ if xlims is None: tt = ax_zoomed.transScale + (ax_zoomed.transLimits + ax_origin.transAxes) transform = blended_transform_factory(ax_origin.transData, tt) bbox_zoomed=ax_zoomed.bbox bbox_origin=TransformedBbox(ax_zoomed.viewLim, transform) else: transform_zoomed=blended_transform_factory(ax_zoomed.transData, ax_zoomed.transAxes) transform_origin=blended_transform_factory(ax_origin.transData, ax_origin.transAxes) bbox_zoomed=TransformedBbox(Bbox.from_extents(xlims[0], 0, xlims[1], 1), transform_zoomed) bbox_origin=TransformedBbox(Bbox.from_extents(xlims[0], 0, xlims[1], 1), transform_origin) prop_patches = kwargs.copy() prop_patches["ec"] = "none" prop_patches["alpha"] = 0.2 if orientation=='below': loc1a=2 loc2a=3 loc1b=1 loc2b=4 elif orientation=='above': loc1a=3 loc2a=2 loc1b=4 loc2b=1 else: raise Exception("orientation '%s' not recognized" % orientation) c1, c2, bbox_zoomed_patch, bbox_origin_patch, p = \ connect_bbox(bbox_zoomed, bbox_origin, loc1a=loc1a, loc2a=loc2a, loc1b=loc1b, loc2b=loc2b, prop_lines=kwargs, prop_patches=prop_patches) ax_zoomed.add_patch(bbox_zoomed_patch) ax_origin.add_patch(bbox_origin_patch) ax_origin.add_patch(c1) ax_origin.add_patch(c2) ax_origin.add_patch(p) return c1, c2, bbox_zoomed_patch, bbox_origin_patch, p
def plotIToEBrokenAxis(sp, gIdx, neuronIdx, trialNum=0, axBoundaries=None, axesProportions=(0.5, 0.5), bottomLimits=None, topLimits=None, **kw): if axBoundaries is None: axBoundaries = [0, 0, 1, 1] left, bottom, right, top = axBoundaries title = kw.pop('title', 'E cell') fig = kw.pop('fig', plt.gcf()) h = top - bottom w = right - left hBottom = h*axesProportions[0] hTop = h*axesProportions[1] axBottom = fig.add_axes(Bbox.from_extents(left, bottom, right, bottom + hBottom)) axTop = fig.add_axes(Bbox.from_extents(left, top - hTop, right, top), sharex=axBottom) _, gI = aggr.computeYX(sp, iterList) M = sp[0][gIdx][trialNum].data['g_EI'] conns = M[neuronIdx, :] pconn.plotConnHistogram(conns, title=title, ax=axBottom, **kw) kw['ylabel'] = '' pconn.plotConnHistogram(conns, title=title, ax=axTop, **kw) annG = gI[0, gIdx] if annG - int(annG) == 0: annG = int(annG) #ann = '$g_I$ = {0} nS'.format(annG) #fig.text(left+0.95*w, bottom+0.9*h, ann, ha='right', va='bottom', # fontsize='x-small') axBottom.set_xlim([0, annG]) axBottom.set_xticks([0, annG]) axBottom.xaxis.set_ticklabels([0, '$g_I$']) axBottom.set_ylim(bottomLimits) axBottom.set_yticks(bottomLimits) axBottom.yaxis.set_minor_locator(ti.NullLocator()) axTop.set_ylim(topLimits) axTop.set_yticks([topLimits[1]]) axTop.xaxis.set_visible(False) axTop.spines['bottom'].set_visible(False) divLen = 0.07 d = .015 kwargs = dict(transform=fig.transFigure, color='k', clip_on=False) axBottom.plot((left-divLen*w, left+divLen*w), (bottom+hBottom + d, bottom+hBottom - d), **kwargs) axTop.plot((left-divLen*w, left+divLen*w), (top-hTop + d, top-hTop - d), **kwargs) return axBottom, axTop
def plot(self, *args, **kwargs): ps = self.env.ps output_dir = self.config['output_dir'] rateLeft = rasterLeft rateBottom = 0.2 rateRight = rasterRight rateTop = self.myc['rateTop'] for idx, noise_sigma in enumerate(ps.noise_sigmas): # E cells fig = self._get_final_fig(self.myc['fig_size']) ax = fig.add_axes(Bbox.from_extents(rateLeft, rateBottom, rateRight, rateTop)) kw = {} if (idx != 0): kw['ylabel'] = '' rasters.plotAvgFiringRate(ps.bumpGamma[idx], spaceType='bump', noise_sigma=ps.noise_sigmas[idx], popType='E', r=rasterRC[idx][0], c=rasterRC[idx][1], ylabelPos=self.myc['ylabelPos'], color='red', tLimits=tLimits, ax=ax, **kw) fname = output_dir + "/bumps_rate_e{0}.pdf".format(noise_sigma) fig.savefig(fname, dpi=300, transparent=transparent) plt.close() # I cells fig = self._get_final_fig(self.myc['fig_size']) ax = fig.add_axes(Bbox.from_extents(rateLeft, rateBottom, rateRight, rateTop)) kw = {} if (idx != 0): kw['ylabel'] = '' rasters.plotAvgFiringRate(ps.bumpGamma[idx], spaceType='bump', noise_sigma=ps.noise_sigmas[idx], popType='I', r=rasterRC[idx][0], c=rasterRC[idx][1], ylabelPos=self.myc['ylabelPos'], color='blue', tLimits=tLimits, ax=ax, **kw) fname = output_dir + "/bumps_rate_i{0}.pdf".format(noise_sigma) fig.savefig(fname, dpi=300, transparent=transparent) plt.close()
def plot(self, *args, **kwargs): ps = self.env.ps plot_theta = self.myc.get('plot_theta', False) output_dir = self.config['output_dir'] for ns_idx, noise_sigma in enumerate(ps.noise_sigmas): fig = self._get_final_fig(self.myc['fig_size']) # Plot theta signal if requested if plot_theta: tl, tb, tr, tt = self.myc['theta_rect'] ax_theta = fig.add_axes(Bbox.from_extents(tl, tb, tr, tt)) t = np.arange(tLimits[0], tLimits[1] + self.dt, self.dt) theta = ( self.const + .5 * (1. + np.cos(2 * np.pi * self.freq * 1e-3 * t - np.pi)) * (1 - self.const)) ax_theta.fill_between(t, theta, edgecolor='None', color=self.myc['theta_color']) ax_theta.set_xlim([tLimits[0], tLimits[1]]) ax_theta.set_ylim(-.02, 1.02) ax_theta.axis('off') ax = fig.add_axes( Bbox.from_extents(rasterLeft, rasterBottom, rasterRight, rasterTop)) rasters.EIRaster( ps.bumpGamma[ns_idx], noise_sigma=noise_sigma, spaceType='bump', r=rasterRC[ns_idx][0], c=rasterRC[ns_idx][1], ylabelPos=self.myc['ylabelPos'], tLimits=tLimits, markersize=2 * self.config['scale_factor'], ylabel='' if self.myc['yticks'][ns_idx] == False else None, yticks=self.myc['yticks'][ns_idx], scaleBar=self.myc['scaleBar'][ns_idx], scaleX=self.myc['scaleX'], scaleY=self.myc['scaleY'], scaleTextYOffset=.03, scaleHeight=.005, ann_EI=True) fname = "%s/bumps_raster%d.%s" % (output_dir, int(noise_sigma), self.myc['fig_ext']) fig.savefig(fname, dpi=300, transparent=transparent) plt.close()
def plot(self, *args, **kwargs): ps = self.env.ps output_dir = self.config['output_dir'] transparent = self.myc['transparent'] for idx, noise_sigma in enumerate(ps.noise_sigmas): # E cells fig = self._get_final_fig(self.myc['fig_size']) l, b, r, t = self.myc['bbox'] ax = fig.add_axes(Bbox.from_extents(l, b, r, t)) kw = {} if (idx != 0): kw['ylabel'] = '' rasters.plotAvgFiringRate(ps.v[idx], spaceType='velocity', noise_sigma=noise_sigma, popType='E', r=rasterRC[idx][0], c=rasterRC[idx][1], color='red', ylabelPos=self.config['vel_rasters']['ylabelPos'], tLimits=self.config['vel_rasters']['tLimits'], trialNum=self.config['vel_rasters']['trialNum'], sigmaTitle=False, ax=ax, **kw) fname = output_dir + "/velocity_rate_e{0}.pdf".format(noise_sigma) fig.savefig(fname, dpi=300, transparent=transparent) plt.close() # I cells fig = self._get_final_fig(self.myc['fig_size']) ax = fig.add_axes(Bbox.from_extents(l, b, r, t)) kw = {} if (idx != 0): kw['ylabel'] = '' rasters.plotAvgFiringRate(ps.v[idx], spaceType='velocity', noise_sigma=noise_sigma, popType='I', r=rasterRC[idx][0], c=rasterRC[idx][1], color='blue', ylabelPos=self.config['vel_rasters']['ylabelPos'], tLimits=self.config['vel_rasters']['tLimits'], trialNum=self.config['vel_rasters']['trialNum'], sigmaTitle=False, ax=ax, **kw) fname = output_dir + "/velocity_rate_i{0}.pdf".format(noise_sigma) fig.savefig(fname, dpi=300, transparent=transparent) plt.close()
def main(): fig, ax = plt.subplots() years = np.arange(2004, 2009) heights = [7900, 8100, 7900, 6900, 2800] box_colors = [ (0.8, 0.2, 0.2), (0.2, 0.8, 0.2), (0.2, 0.2, 0.8), (0.7, 0.5, 0.8), (0.3, 0.8, 0.7), ] for year, h, bc in zip(years, heights, box_colors): bbox0 = Bbox.from_extents(year - 0.4, 0., year + 0.4, h) bbox = TransformedBbox(bbox0, ax.transData) ax.add_artist(RibbonBoxImage(ax, bbox, bc, interpolation="bicubic")) ax.annotate(str(h), (year, h), va="bottom", ha="center") ax.set_xlim(years[0] - 0.5, years[-1] + 0.5) ax.set_ylim(0, 10000) background_gradient = np.zeros((2, 2, 4)) background_gradient[:, :, :3] = [1, 1, 0] background_gradient[:, :, 3] = [[0.1, 0.3], [0.3, 0.5]] # alpha channel ax.imshow(background_gradient, interpolation="bicubic", zorder=0.1, extent=(0, 1, 0, 1), transform=ax.transAxes, aspect="auto") plt.show()
def plot(self, *args, **kwargs): ylabel_coords = self.myc.get('ylabel_coords', None) x0, x1, dx = self.myc.get('x_range', (-.5, .5, .001)) l, b, r, t = self.myc['bbox_rect'] d = np.arange(x0, x1+dx, dx) y_dim = np.sqrt(3)/2.0 ES_pAMPA_mu = y_dim/2.0 ES_pAMPA_sigma = 0.5/6 ES_pGABA_sigma = 0.5/6 ES_pGABA_const = 0.013 shift = 0.1 # Excitatory surround ES_exc_profile = np.exp(-(np.abs(d) - ES_pAMPA_mu)**2/2/ES_pAMPA_sigma**2) ES_exc_profile_shifted = np.exp(-(np.abs(d - shift) - ES_pAMPA_mu)**2/2/ES_pAMPA_sigma**2) ES_inh_profile = (1-ES_pGABA_const)*np.exp(-d**2/2./ES_pGABA_sigma**2) + ES_pGABA_const fig = self._get_final_fig(self.myc['fig_size']) ax = fig.add_axes(Bbox.from_extents(l, b, r, t)) self.plotWeights(ax, d, ES_exc_profile, ES_inh_profile, ES_pGABA_const, linewidth=self.config['scale_factor'], x_range=(x0, x1, dx)) ax.set_xticks(self.myc.get('xticks', [-.5, .5])) ax.xaxis.set_minor_locator(ti.MultipleLocator(0.5)) ax.xaxis.set_label_coords(x=0.5, y=-0.2) if ylabel_coords is not None: ax.yaxis.set_label_coords(ylabel_coords[0], ylabel_coords[1]) fileName = self.get_fname("{base}_E_surr.pdf", base='fig_conn_func') plt.savefig(fileName, transparent=True)
def zoom_effect(ax1, ax2, xlim, **kwargs): trans1 = blended_transform_factory(ax1.transData, ax1.transAxes) trans2 = blended_transform_factory(ax2.transData, ax2.transAxes) bbox = Bbox.from_extents(xlim[0], 0, xlim[1], 1) tbbox1 = TransformedBbox(bbox, trans1) tbbox2 = TransformedBbox(bbox, trans2) prop_patches = kwargs.copy() prop_patches['ec'] = 'none' prop_patches['alpha'] = 0.1 c1, c2, bbox_patch1, bbox_patch2, p = \ connect_bboxes(tbbox1, tbbox2, loc1a=3, loc2a=2, loc1b=4, loc2b=1, prop_lines=kwargs, prop_patches=prop_patches) ax1.add_patch(bbox_patch1) ax2.add_patch(bbox_patch2) ax2.add_patch(c1) ax2.add_patch(c2) ax2.add_patch(p) return c1, c2, bbox_patch1, bbox_patch2, p
def main(): fig, ax = plt.subplots() years = np.arange(2004, 2009) heights = [7900, 8100, 7900, 6900, 2800] box_colors = [ (0.8, 0.2, 0.2), (0.2, 0.8, 0.2), (0.2, 0.2, 0.8), (0.7, 0.5, 0.8), (0.3, 0.8, 0.7), ] for year, h, bc in zip(years, heights, box_colors): bbox0 = Bbox.from_extents(year - 0.4, 0., year + 0.4, h) bbox = TransformedBbox(bbox0, ax.transData) ax.add_artist(RibbonBoxImage(ax, bbox, bc, interpolation="bicubic")) ax.annotate(str(h), (year, h), va="bottom", ha="center") ax.set_xlim(years[0] - 0.5, years[-1] + 0.5) ax.set_ylim(0, 10000) background_gradient = np.zeros((2, 2, 4)) background_gradient[:, :, :3] = [1, 1, 0] background_gradient[:, :, 3] = [[0.1, 0.3], [0.3, 0.5]] # alpha channel ax.imshow(background_gradient, interpolation="bicubic", zorder=0.1, extent=(0, 1, 0, 1), transform=ax.transAxes, aspect="auto") plt.show()
def test_clip_path(): x = np.array([-3, -2, -1, 0., 1, 2, 3, 2, 1, 0, -1, -2, -3, 5]) y = np.arange(len(x)) fig, ax = plt.subplots() ax.plot(x, y, lw=1) bbox = Bbox.from_extents(-2, 3, 2, 12.5) rect = plt.Rectangle(bbox.p0, bbox.width, bbox.height, facecolor='none', edgecolor='k', ls='--') ax.add_patch(rect) clipped_lines, ticks = clip_line_to_rect(x, y, bbox) for lx, ly in clipped_lines: ax.plot(lx, ly, lw=1, color='C1') for px, py in zip(lx, ly): assert bbox.contains(px, py) ccc = iter(['C3o', 'C2x', 'C3o', 'C2x']) for ttt in ticks: cc = next(ccc) for (xx, yy), aa in ttt: ax.plot([xx], [yy], cc)
def setDirectory(self, rootPath, shape): super(BumpSweepWidget, self).setDirectory(rootPath, shape) sigmaBumpText = '$\sigma_{bump}^{-1}\ (neurons^{-1})$' self.cbar_kw.update(dict( label = sigmaBumpText, ticks = ti.MultipleLocator(0.1))) self.canvas.fig.clear() self.ax = self.canvas.fig.add_axes( Bbox.from_extents(self.sweepLeft, self.sweepBottom, self.sweepRight, self.sweepTop)) self.aggrData = aggr.AggregateBumpReciprocal(self.dataSpace, self.iterList, self.NTrials, tStart=self.bumpTStart) sweeps.plotSweep(self.aggrData, self.noise_sigma, sigmaTitle=False, cbar=True, cbar_kw=self.cbar_kw, ax=self.ax, picker=True) c = self.ax.collections if (len(c) != 1): raise RuntimeError("Something went wrong! len(c) != 1") self.dataCollection = c[0] self.canvas.draw() self.dataRenewed.emit(self.dataSpace)
def zoom_effect01(ax1, ax2, xmin, xmax, **kwargs): """ ax1 : the main axes ax1 : the zoomed axes (xmin,xmax) : the limits of the colored area in both plot axes. connect ax1 & ax2. The x-range of (xmin, xmax) in both axes will be marked. The keywords parameters will be used ti create patches. """ trans1 = blended_transform_factory(ax1.transData, ax1.transAxes) trans2 = blended_transform_factory(ax2.transData, ax2.transAxes) bbox = Bbox.from_extents(xmin, 0, xmax, 1) mybbox1 = TransformedBbox(bbox, trans1) mybbox2 = TransformedBbox(bbox, trans2) prop_patches = kwargs.copy() # prop_patches["ec"] = "none" # prop_patches["alpha"] = 0.1 c1, c2, bbox_patch1, bbox_patch2, p = \ connect_bbox(mybbox1, mybbox2, loc1a=2, loc2a=3, loc1b=1, loc2b=4, prop_lines=kwargs, prop_patches=prop_patches) ax1.add_patch(bbox_patch1) ax2.add_patch(bbox_patch2) ax2.add_patch(c1) ax2.add_patch(c2) ax2.add_patch(p) return c1, c2, bbox_patch1, bbox_patch2, p
def generate_color(): dpi = 72 dpi2 = dpi / 3 F = plt.figure(num=None, figsize=(1.2, 0.75), dpi=dpi, facecolor='w') ax = plt.subplot(111) x = [0, 1, 1, 0, 0] y = [1, 1, 0, 0, 1] ed = ax.transAxes.transform([(0, 0), (1, 1)]) bbox = Bbox.from_extents(ed[0, 0] / dpi, ed[0, 1] / dpi, ed[1, 0] / dpi, ed[1, 1] / dpi) print('### generating color palette button ###') collist = color_list() for color in collist: ax.cla() ax.tick_params(length=0) ax.set_axis_off() plt.fill(x, y, color=color) if color == 'none': plt.plot([0, 1], [1, 0], color='red') filename = 'color_' + encode(color) + '.png' plt.savefig(filename, dpi=dpi2, format='png', bbox_inches=bbox) ax.cla() ax.tick_params(length=0) ax.set_axis_off() ax.text(0.5, 0.2, '?', ha='center', fontsize=30) filename = 'color_' + encode('other') + '.png' plt.savefig(filename, dpi=dpi2, format='png', bbox_inches=bbox)
def generate_colormap(): dpi = 72 dpi2 = dpi F = plt.figure(num=None, figsize=(2.4, 0.3), dpi=dpi, facecolor='w') x = [0, 1, 1, 0, 0] y = [1, 1, 0, 0, 1] print('### generating colormap palette button ###') idl_names = register_idl_colormaps() a = np.linspace(0, 1, 256).reshape(1, -1) a = np.vstack([a] * 20) maps = [colormap_list()[0]] + colormap_list() + idl_names for map in maps: ax = plt.subplot(111) ax.cla() ax.tick_params(length=0) ax.set_axis_off() plt.imshow(a, cmap=plt.get_cmap(map), origin='lower') filename = 'colormap_' + encode(map) + '.png' ed = ax.transAxes.transform([(0, 0), (1, 1)]) bbox = Bbox.from_extents(ed[0, 0] / dpi, ed[0, 1] / dpi, ed[1, 0] / dpi, ed[1, 1] / dpi) plt.savefig(filename, dpi=dpi2, format='png', bbox_inches=bbox)
def zoom_effect(ax1, ax2, xmin, xmax, **kwargs): trans1 = blended_transform_factory(ax1.transData, ax1.transAxes) trans2 = blended_transform_factory(ax2.transData, ax2.transAxes) bbox = Bbox.from_extents(xmin, 0, xmax, 1) mybbox1 = TransformedBbox(bbox, trans1) mybbox2 = TransformedBbox(bbox, trans2) prop_patches = {**kwargs, "ec": "none", "alpha": 0.1} c1, c2, bbox_patch1, bbox_patch2, p = connect_bbox( mybbox1, mybbox2, loc1a=3, loc2a=2, loc1b=4, loc2b=1, prop_lines=kwargs, prop_patches=prop_patches) ax1.add_patch(bbox_patch1) ax2.add_patch(bbox_patch2) ax2.add_patch(c1) ax2.add_patch(c2) ax2.add_patch(p) return c1, c2, bbox_patch1, bbox_patch2, p
def plot(self, *args, **kwargs): ps = self.env.ps output_dir = self.config['output_dir'] l, b, r, t = self.myc['bbox'] transparent = self.myc['transparent'] tLimits = [2.75e3, 2.875e3] # ms trialNum = 0 for idx, noise_sigma in enumerate(ps.noise_sigmas): fig = self._get_final_fig(self.myc['fig_size']) ax = fig.add_axes(Bbox.from_extents(l, b, r, t)) kw = dict(scaleBar=None) if idx == 2: kw['scaleBar'] = 25 rasters.EIRaster(ps.v[idx], noise_sigma=noise_sigma, spaceType='velocity', r=rasterRC[idx][0], c=rasterRC[idx][1], ylabelPos=self.myc['ylabelPos'], tLimits=tLimits, trialNum=trialNum, sigmaTitle=False, ann_EI=True, scaleX=0.75, scaleY=-0.15, ylabel='', yticks=False, **kw) fname = output_dir + "/velocity_raster_zooms{0}.png" fig.savefig(fname.format(int(noise_sigma)), dpi=300, transparent=transparent) plt.close()
def get_bbox(self): """ Leave some room around the bars """ x = self.get_xticks() y = self.get_yticks() return Bbox.from_extents(-0.2, 0, x[-1] + 0.6, y[-1] + 1)
def find_component_bounds(self, components: List[str], zoom: float = 1.2): """Find bounds of a set of components. Args: components (List[str]): A list of component names zoom (float): Fraction to expand the bounding vbox by Returns: List: List of x,y coordinates defining the bounding box """ if len(components) == 0: self.logger.error('At least one component must be provided.') # initialize bounds bounds = [float("inf"), float("inf"), float("-inf"), float("-inf")] for name in components: # self.design.components[name] component = self.design.components[name] # return (minx, miny, maxx, maxy) newbounds = component.qgeometry_bounds() bbox = Bbox.from_extents(newbounds) newbounds = bbox.expanded(zoom, zoom).extents # re-calculate total bounds by adding current component bounds = [ min(newbounds[0], bounds[0]), min(newbounds[1], bounds[1]), max(newbounds[2], bounds[2]), max(newbounds[3], bounds[3]) ] return bounds
def plot(self, *args, **kwargs): ps = self.env.ps xlabel = self.myc.get('xlabel', None) ylabel = self.myc.get('ylabel', None) xticks = self.myc['xticks'] yticks = self.myc['yticks'] l, b, r, t = self.myc['bbox'] normalize_ticks = self.myc.get('normalize_ticks', False) normalize_type = self.myc.get('normalize_type', None) fname = self.myc.get('fname', "generic_1d_sweep_{ns}.pdf") for ns_idx, noise_sigma in enumerate(ps.noise_sigmas): file_name = self.get_fname(fname, ns=noise_sigma) fig = self._get_final_fig(self.config['sweeps']['fig_size']) ax = fig.add_axes(Bbox.from_extents(l, b, r, t)) sweeps.plot_1d_sweep( self.get_data(ns_idx), ax, xlabel='' if xticks[ns_idx] == False else xlabel, xticks=xticks[ns_idx], ylabel='' if yticks[ns_idx] == False else ylabel, yticks=yticks[ns_idx], title=noise_sigma, axis_setting=self.myc.get('axis_setting', 'scaled')) ax.set_xlim(self.myc.get('xlim', (None, None))) ax.set_ylim(self.myc.get('ylim', (None, None))) ax.yaxis.set_minor_locator(ti.AutoMinorLocator(2)) fig.savefig(file_name, dpi=300, transparent=True) plt.close(fig)
def plot(self, *args, **kwargs): ps = self.env.ps output_dir = self.config['output_dir'] iter_list = self.config['iter_list'] l, b, r, t = self.myc['bbox_rect'] for ns_idx, noise_sigma in enumerate(ps.noise_sigmas): fig = self._get_final_fig(self.myc['fig_size']) ax = fig.add_axes(Bbox.from_extents(l, b, r, t)) kwargs = dict() if ns_idx != 1: kwargs['xlabel'] = '' if ns_idx != 0: kwargs['ylabel'] = '' self.plotSlopes( ax, ps.v[ns_idx], self.myc['positions'][ns_idx], noise_sigma=noise_sigma, iterList=iter_list, color='blue', ivel_range=self.myc.get('ivel_range', None), g_ann=self.myc.get('g_ann', True), **kwargs) fname = (self.config['output_dir'] + "/velocity_slope_examples_{0}.pdf".format(int(noise_sigma))) plt.savefig(fname, dpi=300, transparent=True)
def plot(self, *args, **kwargs): ps = self.env.ps output_dir = self.config['output_dir'] logger.info("Plotting rasters") for idx, noise_sigma in enumerate(ps.noise_sigmas): logger.info(" Rasters: %d pA", noise_sigma) fig = self._get_final_fig(self.myc['fig_size']) l, b, r, t = self.myc['bbox'] ax = fig.add_axes(Bbox.from_extents(l, b, r, t)) kw = dict(scaleBar=None) if (idx != 0): kw['ylabel'] = '' kw['yticks'] = False if idx == 2: kw['scaleBar'] = 125 rasters.EIRaster(ps.v[idx], noise_sigma=noise_sigma, spaceType='velocity', r=rasterRC[idx][0], c=rasterRC[idx][1], ylabelPos=self.config['vel_rasters']['ylabelPos'], tLimits=self.config['vel_rasters']['tLimits'], trialNum=self.config['vel_rasters']['trialNum'], ann_EI=True, scaleX=0.85, scaleY=-0.15, **kw) fname = output_dir + "/velocity_raster{0}.png" fig.savefig(fname.format(int(noise_sigma)), dpi=300, transparent=self.myc['transparent']) plt.close()
def zoom_by_factor(self, factor, x, y): """Zoom by factor around point defined by x, y coordinates""" # Compute ratios around x,y current_bbox = self.current_bbox() left = (x - current_bbox.xmin) / current_bbox.width right = (current_bbox.xmax - x) / current_bbox.width bottom = (y - current_bbox.ymin) / current_bbox.height top = (current_bbox.ymax - y) / current_bbox.height # Apply zoom factor on sizes width, height = self.width() / factor, self.height() / factor limits = self.limits() if width > limits.width: width = limits.width if height > limits.height: height = limits.height # Apply new sizes with same ratios around x,y bbox = Bbox.from_extents( x - left * width, y - bottom * height, x + right * width, y + top * height, ) self.apply_bbox(self.constrained_bbox(bbox, limits))
def __init__(self, axes, zorder, features, plasmid_size, radius, feature_width, spacing, arrow_head_length, label, face_properties, label_properties, omit_oversized_labels, feature_formatter): super().__init__() self._axes = axes self.zorder = zorder self._features = features self._plasmid_size = plasmid_size self._radius = radius self._feature_width = feature_width self._spacing = spacing self._all_indicators = [] for feature in features: indicators_for_feature = [] for loc in feature.locs: # Set proper positions in 'draw()' method bbox = Bbox.from_extents(0, 0, 0, 0) # Draw features as curved arrows (feature indicator) indicator = axes.add_artist( Feature_Indicator(axes, self.zorder + 1, feature, loc, bbox, arrow_head_length, face_properties, label_properties, omit_oversized_labels, feature_formatter)) indicators_for_feature.append(indicator) self._all_indicators.append(indicators_for_feature)
def zoom_effect01(ax1, ax2, xmin, xmax, **kwargs): u""" ax1 : the main axes ax1 : the zoomed axes (xmin,xmax) : the limits of the colored area in both plot axes. connect ax1 & ax2. The x-range of (xmin, xmax) in both axes will be marked. The keywords parameters will be used ti create patches. """ trans1 = blended_transform_factory(ax1.transData, ax1.transAxes) trans2 = blended_transform_factory(ax2.transData, ax2.transAxes) bbox = Bbox.from_extents(xmin, 0, xmax, 1) mybbox1 = TransformedBbox(bbox, trans1) mybbox2 = TransformedBbox(bbox, trans2) prop_patches=kwargs.copy() prop_patches["ec"]="none" prop_patches["alpha"]=0.2 c1, c2, bbox_patch1, bbox_patch2, p = \ connect_bbox(mybbox1, mybbox2, loc1a=3, loc2a=2, loc1b=4, loc2b=1, prop_lines=kwargs, prop_patches=prop_patches) ax1.add_patch(bbox_patch1) ax2.add_patch(bbox_patch2) ax2.add_patch(c1) ax2.add_patch(c2) ax2.add_patch(p) return c1, c2, bbox_patch1, bbox_patch2, p
def plot(self, *args, **kwargs): ps = self.env.ps xlabel = self.myc.get('xlabel', None) ylabel = self.myc.get('ylabel', None) xticks = self.myc['xticks'] yticks = self.myc['yticks'] l, b, r, t = self.myc['bbox'] normalize_ticks = self.myc.get('normalize_ticks', False) normalize_type = self.myc.get('normalize_type', None) fname = self.myc.get('fname', "generic_1d_sweep_{ns}.pdf") for ns_idx, noise_sigma in enumerate(ps.noise_sigmas): file_name = self.get_fname(fname, ns=noise_sigma) fig = self._get_final_fig(self.config['sweeps']['fig_size']) ax = fig.add_axes(Bbox.from_extents(l, b, r, t)) sweeps.plot_1d_sweep( self.get_data(ns_idx), ax, xlabel='' if xticks[ns_idx] == False else xlabel, xticks=xticks[ns_idx], ylabel='' if yticks[ns_idx] == False else ylabel, yticks=yticks[ns_idx], title=noise_sigma, axis_setting=self.myc.get('axis_setting', 'scaled')) ax.set_xlim(self.myc.get('xlim', (None, None))) ax.set_ylim(self.myc.get('ylim', (None, None))) ax.yaxis.set_minor_locator(ti.AutoMinorLocator(2)) fig.savefig(file_name, dpi=300, transparent=True) plt.close(fig)
def setDirectory(self, rootPath, shape): super(GridSweepWidget, self).setDirectory(rootPath, shape) self.canvas.fig.clear() self.ax = self.canvas.fig.add_axes( Bbox.from_extents(self.sweepLeft, self.sweepBottom, self.sweepRight, self.sweepTop)) self.cbar_kw.update({ 'label' : 'Gridness score', 'ticks' : ti.MultipleLocator(0.5)}) sweeps.plotGridTrial(self.dataSpace, self.varList, self.iterList, self.noise_sigma, trialNumList=[], sigmaTitle=False, ignoreNaNs=True, r=5, c=15, cbar=True, cbar_kw=self.cbar_kw, ax=self.ax, picker=True) c = self.ax.collections if (len(c) != 1): raise RuntimeError("Something went wrong! len(c) != 1") self.dataCollection = c[0] self.canvas.draw() self.dataRenewed.emit(self.dataSpace)
def generate_plinestyle(): dpi = 72 dpi2 = dpi * 5 if isMPL2 else dpi F = plt.figure(num=None, figsize=(0.4, 0.25), dpi=dpi, facecolor='w') ax = plt.subplot(111) x = [0, 1, 1, 0, 0] y = [1, 1, 0, 0, 1] ed = ax.transAxes.transform([(0, 0), (1, 1)]) bbox = Bbox.from_extents(ed[0, 0] / dpi, ed[0, 1] / dpi, ed[1, 0] / dpi, ed[1, 1] / dpi) print('### generating patch linestyle palette button ###') plinestylelist = plinestyle_list() x = [0, 0.5, 1] y = [0.5, 0.5, 0.5] for plinestyle in plinestylelist: ax.cla() ax.tick_params(length=0) ax.set_axis_off() plt.axhspan(0.5, 0.5, linestyle=plinestyle, edgecolor='black', facecolor='white', linewidth=2) filename = 'plinestyle_' + encode(str(plinestyle)) + '.png' plt.savefig(filename, dpi=dpi2, format='png', bbox_inches=bbox) # plt produces blured image on MPL2.0 if isMPL2: im = wx.Image(filename) w, h = im.GetSize() im.Rescale(w / 5, h / 5).SaveFile(filename, wx.BITMAP_TYPE_PNG)
def plot(self, *args, **kwargs): # 1st autocorrelation peak (gamma power) types = ('gamma', 'acVal') fig = self._get_final_fig(detailFigSize) ax = fig.add_axes(Bbox.from_extents(detailLeft, detailBottom, detailRight, detailTop)) _, p13, l13 = details.plotDetailedNoise(EI13PS, detailedNTrials, types, ax=ax, ylabelPos=self.ylabelPos, xlabel='', xticks=False, color='red', markerfacecolor='red', zorder=10) _, p31, l31 = details.plotDetailedNoise(EI31PS, detailedNTrials, types, ax=ax, xlabel='', xticks=False, ylabel='$1^{st}$\nautocorrelation\npeak', ylabelPos=self.ylabelPos, color='#505050') ax.xaxis.set_visible(False) ax.spines['bottom'].set_visible(False) ax.yaxis.set_major_locator(ti.MultipleLocator(0.6)) ax.yaxis.set_minor_locator(ti.AutoMinorLocator(6)) ax.set_ylim(prepareLims((0, 0.6), margin=0.03)) leg = self.myc['legend'] l = ax.legend([p31, p13], leg, **self.myc['legend_kwargs']) plt.setp(l.get_title(), fontsize='small') fname = self.config['output_dir'] + "/gamma_detailed_noise_power.pdf" plt.savefig(fname, dpi=300, transparent=True) plt.close() # Gamma frequency types = ('gamma', 'freq') fig = self._get_final_fig(detailFigSize) ax = fig.add_axes(Bbox.from_extents(detailLeft, detailBottom, detailRight, detailTop)) _, p13, l13 = details.plotDetailedNoise(EI13PS, detailedNTrials, types, ax=ax, ylabelPos=self.ylabelPos, xlabel='', color='red', markerfacecolor='red', zorder=10) _, p31, l31 = details.plotDetailedNoise(EI31PS, detailedNTrials, types, ax=ax, ylabel='Oscillation\nfrequency (Hz)', ylabelPos=self.ylabelPos, color='#505050') ax.yaxis.set_major_locator(ti.MultipleLocator(30)) ax.yaxis.set_minor_locator(ti.AutoMinorLocator(3)) ax.set_ylim(prepareLims((30, 90), margin=0.03)) fname = self.config['output_dir'] + "/gamma_detailed_noise_freq.pdf" plt.savefig(fname, dpi=300, transparent=True) plt.close()
def plot(self, *args, **kwargs): ps = self.env.ps myc = self._get_class_config() iter_list = self.config["iter_list"] l, b, r, t = self.myc["bbox_rect"] legend = self.myc.get("legend", True) legend_kwargs = myc["legend_kwargs"] xlabel = self.myc.get("xlabel", "P(bumps)") ylabel = "Gridness score" fig = self._get_final_fig(myc["fig_size"]) ax = fig.add_axes(Bbox.from_extents(l, b, r, t)) scatterColors = ["green", "red", "blue"] scatterOrders = [2, 3, 1] for ns_idx, noise_sigma in enumerate(ps.noise_sigmas): isBumpData = aggr.IsBump(ps.bumpGamma[ns_idx], iter_list, ignoreNaNs=True) gridData = aggr.GridnessScore(ps.grids[ns_idx], iter_list, ignoreNaNs=True, normalizeTicks=False) scatterPlot = scatter.ScatterPlot( isBumpData, gridData, None, None, None, None, None, c=scatterColors[ns_idx], s=6 * self.config["scale_factor"], linewidth=0.3, xlabel=xlabel, ylabel=ylabel, ax=ax, zorder=scatterOrders[ns_idx], ) scatterPlot.plot() ax.xaxis.set_major_locator(ti.MultipleLocator(0.2)) ax.yaxis.set_major_locator(ti.MultipleLocator(0.5)) if legend: leg = ["0", "150", "300"] l = ax.legend(leg, **legend_kwargs) plt.setp(l.get_title(), size="small") # ax.set_ylabel(ax.get_ylabel(), y=0., ha='left') # Normal scale fname = self.config["output_dir"] + "/bumps_scatter_grids_vs_bumpFracTotal.pdf" fig.savefig(fname, dpi=300, transparent=True) # Exponential scale ax.set_xscale("exponential") ax.xaxis.set_major_locator(ti.MultipleLocator(0.5)) ax.xaxis.set_minor_locator(ti.MultipleLocator(0.1)) ax.set_xlim([-0.3, 1.002]) fname = self.config["output_dir"] + "/bumps_scatter_grids_vs_bumpFracTotal_exp.pdf" fig.savefig(fname, dpi=300, transparent=True)
def get_grid_info(self, x1, y1, x2, y2): """ lon_values, lat_values : list of grid values. if integer is given, rough number of grids in each direction. """ extremes = self.extreme_finder(self.inv_transform_xy, x1, y1, x2, y2) # min & max rage of lat (or lon) for each grid line will be drawn. # i.e., gridline of lon=0 will be drawn from lat_min to lat_max. lon_min, lon_max, lat_min, lat_max = extremes lon_levs, lon_n, lon_factor = self.grid_locator1(lon_min, lon_max) lat_levs, lat_n, lat_factor = self.grid_locator2(lat_min, lat_max) if lon_factor is None: lon_values = np.asarray(lon_levs[:lon_n]) else: lon_values = np.asarray(lon_levs[:lon_n] / lon_factor) if lat_factor is None: lat_values = np.asarray(lat_levs[:lat_n]) else: lat_values = np.asarray(lat_levs[:lat_n] / lat_factor) lon_lines, lat_lines = self._get_raw_grid_lines( lon_values, lat_values, lon_min, lon_max, lat_min, lat_max) ddx = (x2 - x1) * 1.e-10 ddy = (y2 - y1) * 1.e-10 bb = Bbox.from_extents(x1 - ddx, y1 - ddy, x2 + ddx, y2 + ddy) grid_info = { "extremes": extremes, "lon_lines": lon_lines, "lat_lines": lat_lines, "lon": self._clip_grid_lines_and_find_ticks(lon_lines, lon_values, lon_levs, bb), "lat": self._clip_grid_lines_and_find_ticks(lat_lines, lat_values, lat_levs, bb), } tck_labels = grid_info["lon"]["tick_labels"] = {} for direction in ["left", "bottom", "right", "top"]: levs = grid_info["lon"]["tick_levels"][direction] tck_labels[direction] = self.tick_formatter1( direction, lon_factor, levs) tck_labels = grid_info["lat"]["tick_labels"] = {} for direction in ["left", "bottom", "right", "top"]: levs = grid_info["lat"]["tick_levels"][direction] tck_labels[direction] = self.tick_formatter2( direction, lat_factor, levs) return grid_info
def plot(self, *args, **kwargs): ps = self.env.ps normalize_type = self.myc.get('normalize_type', (None, None)) l, b, r, t = self.myc['bbox'] fname = self.myc.get('fname', "gamma_power_generic_{ns}.pdf") for ns_idx, noise_sigma in enumerate(ps.noise_sigmas): metadata = GenericExtractor(ps.bumpGamma[ns_idx], normalize=self.myc['normalize_ticks'], normalize_type=normalize_type) data = aggr.GammaAggregateData(self.myc['what'], ps.bumpGamma[ns_idx], None, normalizeTicks=True, ignoreNaNs=True, metadata_extractor=metadata) if self.myc.get('filter_with_gridness', False): gridData = aggr.GridnessScore(ps.grids[ns_idx], None, normalizeTicks=True, collapseTrials=True, ignoreNaNs=True) gridFilter = aggr.GTFilter(gridData, self.myc['gridness_threshold']) data = data.filter_data(gridFilter) fig = self._get_final_fig(self.config['sweeps']['fig_size']) ax = fig.add_axes(Bbox.from_extents(l, b, r, t)) sweeps.plotSweep(data, noise_sigma=ps.noise_sigmas[ns_idx], ax=ax, xlabel=self.myc['xlabel'] if self.myc['xticks'][ns_idx] is not False else '', xticks=self.myc['xticks'][ns_idx], ylabel=self.myc['ylabel'] if self.myc['yticks'][ns_idx] is not False else '', yticks=self.myc['yticks'][ns_idx], sigmaTitle=self.myc['sigma_title'], cbar=self.myc['cbar'][ns_idx], cbar_kw=self.myc['cbar_kw'], vmin=self.myc['vmin'], vmax=self.myc['vmax'], annotations=self.myc['ann']) if self.myc['plot_grid_contours'][ns_idx]: gridData = aggr.GridnessScore(ps.grids[ns_idx], None, ignoreNaNs=True, normalizeTicks=True) contours = sweeps.Contours( gridData, self.config['sweeps']['grid_contours']) contours.plot(ax, **self.config['sweeps']['contours_kwargs']) ax.axis('tight') fig.savefig(self.get_fname(fname, ns=noise_sigma), dpi=300, transparent=True) plt.close(fig)
def translated_bbox(self, bbox, dx, dy): """Translate bbox by dx and dy""" return Bbox.from_extents( bbox.xmin + dx, bbox.ymin + dy, bbox.xmax + dx, bbox.ymax + dy, )
def plot(self, *args, **kwargs): ps = self.env.ps plot_theta = self.myc.get('plot_theta', False) output_dir = self.config['output_dir'] for ns_idx, noise_sigma in enumerate(ps.noise_sigmas): fig = self._get_final_fig(self.myc['fig_size']) # Plot theta signal if requested if plot_theta: tl, tb, tr, tt = self.myc['theta_rect'] ax_theta = fig.add_axes(Bbox.from_extents(tl, tb, tr, tt)) t = np.arange(tLimits[0], tLimits[1]+self.dt, self.dt) theta = (self.const + .5 * (1. + np.cos(2*np.pi*self.freq*1e-3*t - np.pi)) * (1 - self.const)) ax_theta.fill_between(t, theta, edgecolor='None', color=self.myc['theta_color']) ax_theta.set_xlim([tLimits[0], tLimits[1]]) ax_theta.set_ylim(-.02, 1.02) ax_theta.axis('off') ax = fig.add_axes(Bbox.from_extents(rasterLeft, rasterBottom, rasterRight, rasterTop)) rasters.EIRaster( ps.bumpGamma[ns_idx], noise_sigma=noise_sigma, spaceType='bump', r=rasterRC[ns_idx][0], c=rasterRC[ns_idx][1], ylabelPos=self.myc['ylabelPos'], tLimits=tLimits, markersize=2*self.config['scale_factor'], ylabel='' if self.myc['yticks'][ns_idx] == False else None, yticks=self.myc['yticks'][ns_idx], scaleBar=self.myc['scaleBar'][ns_idx], scaleX=self.myc['scaleX'], scaleY=self.myc['scaleY'], scaleTextYOffset=.03, scaleHeight=.005, ann_EI=True) fname = "%s/bumps_raster%d.%s" % (output_dir, int(noise_sigma), self.myc['fig_ext']) fig.savefig(fname, dpi=300, transparent=transparent) plt.close()
def get_bbox(self): """ Leave some room around the bars """ max_fn = self.fn.max() min_fn = self.fn.min() max_time = self.time.max() min_time = self.time.min() return Bbox.from_extents(min_time, min_fn, max_time, max_fn)
def _modified_bbox(self, bbox=None): if bbox is None: return Bbox.from_extents( np.min(self.lon), np.min(self.lat), np.max(self.lon), np.max(self.lat) ) return bbox
def plot(self, *args, **kwargs): iter_list = self.config["iter_list"] sigma_bump_text = self.config["bump_sigma"]["sigma_bump_text"] EI13Root = "simulation_data/main_network/detailed_noise/gamma_bump/EI-1_3" EI31Root = "simulation_data/main_network/detailed_noise/gamma_bump/EI-3_1" detailedShape = (31, 9) EI13PS = JobTrialSpace2D(detailedShape, EI13Root) EI31PS = JobTrialSpace2D(detailedShape, EI31Root) detailedNTrials = 5 ylabelPos = -0.17 detailFigSize = (3.8, 2.6) detailLeft = 0.18 detailBottom = 0.26 detailRight = 0.95 detailTop = 0.95 iter_list = ["noise_sigma", "g_AMPA_total"] types = ("bump", "sigma") fig = plt.figure(figsize=detailFigSize) ax = fig.add_axes(Bbox.from_extents(detailLeft, detailBottom, detailRight, detailTop)) data13 = aggr.AggregateBumpReciprocal( EI13PS, iter_list, detailedNTrials, tStart=bumpTStart, normalizeTicks=False ) _, p13, l13 = details.plotDetailedNoise( data13, None, None, ax=ax, ylabel=sigma_bump_text, ylabelPos=ylabelPos, color="red", markerfacecolor="red", zorder=10, ) data31 = aggr.AggregateBumpReciprocal( EI31PS, iter_list, detailedNTrials, tStart=bumpTStart, normalizeTicks=False ) _, p31, l31 = details.plotDetailedNoise(data31, None, None, ax=ax, ylabelPos=ylabelPos, color="#505050") # ax.set_yscale("log") # ax.set_ylim([1.5, 300]) leg = ["a", "b"] l = ax.legend( [p31, p13], leg, loc=(0.85, 0.1), fontsize="small", frameon=False, numpoints=1, handletextpad=0.05 ) plt.setp(l.get_title(), fontsize="small") fname = self.config["output_dir"] + "/bumps_detailed_noise_sigma.pdf" plt.savefig(fname, dpi=300, transparent=True) plt.close()
def plot(self, *args, **kwargs): ps = self.env.ps output_dir = self.config['output_dir'] exampleFigSize = (1.6, 1.4) exLeft = 0.4 exBottom = 0.32 exRight = 0.95 exTop = 0.85 exampleRC = ((5, 15), (15, 5)) for exIdx, example in enumerate(exampleRC): kw = dict() if exIdx == 1: kw['xlabel'] = '' fig = self._get_final_fig(exampleFigSize) ax = fig.add_axes( Bbox.from_extents(exLeft, exBottom, exRight, exTop)) plotEToI(ps.conn, example[0], self.neuronIdx, ylabel='', title='', rwidth=0.8, linewidth=0, **kw) ax.yaxis.set_minor_locator(ti.NullLocator()) ax.set_xlabel(ax.xaxis.get_label_text(), labelpad=-5) fname = output_dir + "/figure_connections_examples_E2I{0}.pdf" plt.savefig(fname.format(exIdx), dpi=300, transparent=True) plt.close() fig = self._get_final_fig(exampleFigSize) axBoundaries = (exLeft, exBottom, exRight, exTop) axBottom, axTop = plotIToEBrokenAxis(ps.conn, example[1], self.neuronIdx, ylabel='', title='', axBoundaries=axBoundaries, axesProportions=(0.75, 0.2), bottomLimits=(0, 60), topLimits=(800, 900), rwidth=0.8, linewidth=0, **kw) axBottom.set_xlabel(axBottom.xaxis.get_label_text(), labelpad=-5) fig.text(exLeft - 0.27, 0.5 * (self.bottom + self.top), 'Count', rotation=90, ha='center', va='center') fname = output_dir + "/figure_connections_examples_I2E{0}.pdf" plt.savefig(fname.format(exIdx), dpi=300, transparent=True) plt.close()
def plotBumpSnapshots(FR, FRt, tstep, **kw): '''Snapshots of bumps in time.''' fig = kw.pop('fig') timeTitles = kw.pop('timeTitles', True) axesCoords = kw.pop('axesCoords', (0.12, 0.01, 0.92, 0.7)) axesDiv = kw.pop('axesDiv', .01) bumpQuality = kw.pop('bumpQuality', False) bumpQualityText = kw.pop('bumpQualityText', '') bumpQualityX = kw.pop('bumpQualityX', -.9) maxRateColor = kw.pop('maxRateColor', 'w') left, bottom, right, top = axesCoords width = right - left height = top - bottom indexes = range(0, FRt.shape[0], tstep) oneWidth = float(width) / len(indexes) l = left bot = bottom max = np.max(FR[:, :, indexes]) lastIndex = len(indexes) - 1 idx = 0 for it in indexes: print(it) t = bot + height r = l + oneWidth - axesDiv print(l, bot, r, top) ax = fig.add_axes(Bbox.from_extents(l, bot, r, top)) plotBump(ax, FR[:, :, it], vmin=0, vmax=max, rasterized=True, **kw) if idx == lastIndex: rateText = "%.0f Hz" % max ax.text(1.05, .95, rateText, ha='left', va='top', color=maxRateColor, transform=ax.transAxes, size='small', weight='bold', clip_on=False) if bumpQuality and it == 0: txt = '{0:.2f}'.format(bumpQuality) ax.text(bumpQualityX, .5, txt, va='center', ha='center', transform=ax.transAxes) if timeTitles: yTitle = 1.02 ax.text(.5, yTitle, "{0}".format(FRt[it]*1e-3), size='medium', transform=ax.transAxes, va='bottom', ha='center') if it == 0: ax.text(.5, yTitle + .3, "t(s)", ha='center', va='bottom', transform=ax.transAxes) ax.text(bumpQualityX, yTitle, bumpQualityText, ha='center', va='bottom', transform=ax.transAxes) l += oneWidth idx += 1 return max # Hack, but hopefully ok for now
def onselect(self, eclick, erelease): if self.coord is None: return left, bottom = min(eclick.xdata, erelease.xdata), min(eclick.ydata, erelease.ydata) right, top = max(eclick.xdata, erelease.xdata), max(eclick.ydata, erelease.ydata) region = Bbox.from_extents(left, bottom, right, top) selectedIds = [] for (xy, idd) in zip(self.matrix.values, self.matrix.ids): if region.contains(xy[0], xy[1]): selectedIds.append(idd) self.coord.notifyModules(selectedIds)
def onselect(self, eclick, erelease): if (self.coord is None): return left, bottom = min(eclick.xdata, erelease.xdata), min(eclick.ydata, erelease.ydata) right, top = max(eclick.xdata, erelease.xdata), max(eclick.ydata, erelease.ydata) region = Bbox.from_extents(left, bottom, right, top) selectedIds = [] for (x, y, idd) in zip(self.Xs, self.Ys, self.stats.ids): if region.contains(x, y): selectedIds.append(idd) self.coord.notifyModules(selectedIds)
def get_grid_info(self, x1, y1, x2, y2): """ lon_values, lat_values : list of grid values. if integer is given, rough number of grids in each direction. """ extremes = self.extreme_finder(self.inv_transform_xy, x1, y1, x2, y2) lon_min, lon_max, lat_min, lat_max = extremes lon_levs, lon_n, lon_factor = \ self.grid_locator1(lon_min, lon_max) lat_levs, lat_n, lat_factor = \ self.grid_locator2(lat_min, lat_max) if lon_factor is None: lon_values = np.asarray(lon_levs[:lon_n]) else: lon_values = np.asarray(lon_levs[:lon_n]/lon_factor) if lat_factor is None: lat_values = np.asarray(lat_levs[:lat_n]) else: lat_values = np.asarray(lat_levs[:lat_n]/lat_factor) lon_lines, lat_lines = self._get_raw_grid_lines(lon_values, lat_values, lon_min, lon_max, lat_min, lat_max) ddx = (x2-x1)*1.e-10 ddy = (y2-y1)*1.e-10 bb = Bbox.from_extents(x1-ddx, y1-ddy, x2+ddx, y2+ddy) grid_info = {} grid_info["extremes"] = extremes grid_info["lon_lines"] = lon_lines grid_info["lat_lines"] = lat_lines grid_info["lon"] = self._clip_grid_lines_and_find_ticks(lon_lines, lon_values, lon_levs, bb) grid_info["lat"] = self._clip_grid_lines_and_find_ticks(lat_lines, lat_values, lat_levs, bb) grid_info["lon"]["tick_labels"] = dict() tck_labels = grid_info["lon"]["tick_labels"] for direction in ["left", "bottom", "right", "top"]: levs = grid_info["lon"]["tick_levels"][direction] tck_labels[direction] = self.tick_formatter1(direction, lon_factor, levs) grid_info["lat"]["tick_labels"] = dict() tck_labels = grid_info["lat"]["tick_labels"] for direction in ["left", "bottom", "right", "top"]: levs = grid_info["lat"]["tick_levels"][direction] tck_labels[direction] = self.tick_formatter2(direction, lat_factor, levs) return grid_info
def get_ax(self, fig): color_bar_pos = self._get_class_config()['cbar_kw']['location'] l, b, w, h = self.config['sweeps']['bbox'] if color_bar_pos == 'right': left = l elif color_bar_pos == 'left': left = .12 else: left = .2 right = left + w top = b + h return fig.add_axes(Bbox.from_extents(left, b, right, top))
def get_grid_info(self, x1, y1, x2, y2): """ lon_values, lat_values : list of grid values. if integer is given, rough number of grids in each direction. """ extremes = self.extreme_finder(self.inv_transform_xy, x1, y1, x2, y2) # min & max rage of lat (or lon) for each grid line will be drawn. # i.e., gridline of lon=0 will be drawn from lat_min to lat_max. lon_min, lon_max, lat_min, lat_max = extremes lon_levs, lon_n, lon_factor = self.grid_locator1(lon_min, lon_max) lat_levs, lat_n, lat_factor = self.grid_locator2(lat_min, lat_max) lon_values = lon_levs[:lon_n] / _deprecate_factor_none(lon_factor) lat_values = lat_levs[:lat_n] / _deprecate_factor_none(lat_factor) lon_lines, lat_lines = self._get_raw_grid_lines(lon_values, lat_values, lon_min, lon_max, lat_min, lat_max) ddx = (x2-x1)*1.e-10 ddy = (y2-y1)*1.e-10 bb = Bbox.from_extents(x1-ddx, y1-ddy, x2+ddx, y2+ddy) grid_info = { "extremes": extremes, "lon_lines": lon_lines, "lat_lines": lat_lines, "lon": self._clip_grid_lines_and_find_ticks( lon_lines, lon_values, lon_levs, bb), "lat": self._clip_grid_lines_and_find_ticks( lat_lines, lat_values, lat_levs, bb), } tck_labels = grid_info["lon"]["tick_labels"] = {} for direction in ["left", "bottom", "right", "top"]: levs = grid_info["lon"]["tick_levels"][direction] tck_labels[direction] = self.tick_formatter1( direction, lon_factor, levs) tck_labels = grid_info["lat"]["tick_labels"] = {} for direction in ["left", "bottom", "right", "top"]: levs = grid_info["lat"]["tick_levels"][direction] tck_labels[direction] = self.tick_formatter2( direction, lat_factor, levs) return grid_info
def cust_mark_inset(parent_axes, inset_axes, x1,x2,y1,y2, loc11,loc12,loc21,loc22,**kwargs): print parent_axes.transData print inset_axes.viewLim rect = TransformedBbox(Bbox.from_extents([x1,y1,x2,y2]), parent_axes.transData) pp = BboxPatch(rect, **kwargs) parent_axes.add_patch(pp) p1 = BboxConnector(inset_axes.bbox, rect, loc1=loc11,loc2=loc12, **kwargs) inset_axes.add_patch(p1) p1.set_clip_on(False) p2 = BboxConnector(inset_axes.bbox, rect, loc1=loc21,loc2=loc22, **kwargs) inset_axes.add_patch(p2) p2.set_clip_on(False)
def zoomEffect(self, ax, xmin, xmax, **kwargs): """ ax : the main axes (xmin,xmax) : the limits of the colored area in the axis """ trans = blended_transform_factory(ax.transData, ax.transAxes) bbox = Bbox.from_extents(xmin, 0, xmax, 1) mybbox = TransformedBbox(bbox, trans) prop_patches=kwargs.copy() prop_patches["ec"]="none" prop_patches["alpha"]=0.2 bbox_patch = BboxPatch(mybbox, **prop_patches) ax.add_patch(bbox_patch)
def plot(self, *args, **kwargs): ps = self.env.ps iter_list = self.config["iter_list"] l, b, r, t = self.myc["bbox_rect"] scatterColors = ["green", "red", "blue"] scatterOrders = [2, 3, 1] # E cells fig = self._get_final_fig(self.myc["fig_size"]) ax = fig.add_axes(Bbox.from_extents(l, b, r, t)) ax.hold("on") xlabel = "Mean E firing rate (Hz)" for ns_idx, noise_sigma in enumerate(ps.noise_sigmas): grid_data = aggr.GridnessScore(ps.grids[ns_idx], iter_list, ignoreNaNs=True, normalizeTicks=False) fre_data = aggr.AvgPopulationFR( "FR_e/avg", ps.grids[ns_idx], iter_list, ignoreNaNs=True, normalizeTicks=False ) color = scatterColors[ns_idx] scatterPlot = scatter.ScatterPlot( fre_data, grid_data, None, None, None, None, None, c=color, s=self.myc["dot_size"] * self.config["scale_factor"], linewidth=0.3, xlabel=xlabel, ylabel=self.myc["ylabel"], yticks=self.myc["yticks"], zorder=scatterOrders[ns_idx], ) scatterPlot.plot() ax.xaxis.set_major_locator(ti.MultipleLocator(10)) ax.yaxis.set_major_locator(ti.MultipleLocator(0.5)) ax.yaxis.set_minor_locator(ti.MultipleLocator(0.25)) leg = ["0", "150", "300"] l = ax.legend(leg, **self.myc["legend_kwargs"]) plt.setp(l.get_title(), size=self.myc["legend_kwargs"]["fontsize"]) fname = self.get_fname("/scatter_FRE_vs_grids.pdf") fig.savefig(fname, dpi=300, transparent=True)
def plot(self, *args, **kwargs): ps = self.env.ps output_dir = self.config['output_dir'] exampleFigSize = (1.6, 1.4) exLeft = 0.4 exBottom = 0.32 exRight = 0.95 exTop = 0.85 exampleRC = ( (5, 15), (15, 5) ) for exIdx, example in enumerate(exampleRC): kw = dict() if exIdx == 1: kw['xlabel'] = '' fig = self._get_final_fig(exampleFigSize) ax = fig.add_axes(Bbox.from_extents(exLeft, exBottom, exRight, exTop)) plotEToI(ps.conn, example[0], self.neuronIdx, ylabel='', title='', rwidth=0.8, linewidth=0, **kw) ax.yaxis.set_minor_locator(ti.NullLocator()) ax.set_xlabel(ax.xaxis.get_label_text(), labelpad=-5) fname = output_dir + "/figure_connections_examples_E2I{0}.pdf" plt.savefig(fname.format(exIdx), dpi=300, transparent=True) plt.close() fig = self._get_final_fig(exampleFigSize) axBoundaries = (exLeft, exBottom, exRight, exTop) axBottom, axTop = plotIToEBrokenAxis(ps.conn, example[1], self.neuronIdx, ylabel='', title='', axBoundaries=axBoundaries, axesProportions=(0.75, 0.2), bottomLimits=(0, 60), topLimits=(800, 900), rwidth=0.8, linewidth=0, **kw) axBottom.set_xlabel(axBottom.xaxis.get_label_text(), labelpad=-5) fig.text(exLeft - 0.27, 0.5*(self.bottom+self.top), 'Count', rotation=90, ha='center', va='center') fname = output_dir + "/figure_connections_examples_I2E{0}.pdf" plt.savefig(fname.format(exIdx), dpi=300, transparent=True) plt.close()
def _bbox_fixed_margin(left, bottom, right, top, fig=None): if not fig: fig = plt.gcf() fig_inches = fig.get_size_inches() fig_w_in, fig_h_in = fig_inches fontsize_rel_h = 12.0/(72*fig_h_in) fontsize_rel_w = 12.0/(72*fig_w_in) box_left_rel = left*fontsize_rel_w box_bottom_rel = bottom*fontsize_rel_h box_right_rel = 1 - right*fontsize_rel_w box_top_rel = 1 - top*fontsize_rel_h return Bbox.from_extents(box_left_rel, box_bottom_rel, box_right_rel, box_top_rel)
def get_position(self, figure, return_all=False): """Update the subplot position from ``figure.subplotpars``. """ gridspec = self.get_gridspec() nrows, ncols = gridspec.get_geometry() rows, cols = np.unravel_index([self.num1, self.num2], (nrows, ncols)) fig_bottoms, fig_tops, fig_lefts, fig_rights = \ gridspec.get_grid_positions(figure) fig_bottom = fig_bottoms[rows].min() fig_top = fig_tops[rows].max() fig_left = fig_lefts[cols].min() fig_right = fig_rights[cols].max() figbox = Bbox.from_extents(fig_left, fig_bottom, fig_right, fig_top) if return_all: return figbox, rows[0], cols[0], nrows, ncols else: return figbox
def plot(self, *args, **kwargs): myc = self._get_class_config() sweepc = self._get_sweep_config() ps = self.env.ps iter_list = self.config["iter_list"] xlabel = self.myc.get("xlabel", None) ylabel = self.myc.get("ylabel", None) xticks = myc["xticks"] yticks = myc["yticks"] vmin = self.myc.get("vmin", self.bump_vmin) vmax = self.myc.get("vmax", self.bump_vmax) normalize_type = self.myc.get("normalize_type", (None, None)) l, b, r, t = self.myc["bbox"] fname = self.myc.get("fname", "bumps_pbumps_generic_{ns}.pdf") for ns_idx, noise_sigma in enumerate(ps.noise_sigmas): file_name = self.get_fname(fname, ns=noise_sigma) fig = self._get_final_fig(self.config["sweeps"]["fig_size"]) ax = fig.add_axes(Bbox.from_extents(l, b, r, t)) metadata = GenericExtractor( ps.bumpGamma[ns_idx], normalize=self.myc["normalize_ticks"], normalize_type=normalize_type ) data = aggr.IsBump(ps.bumpGamma[ns_idx], iter_list, ignoreNaNs=True, metadata_extractor=metadata) sweeps.plotSweep( data, noise_sigma=noise_sigma, sigmaTitle=self.myc.get("sigmaTitle", True), xlabel="" if xticks[ns_idx] == False else xlabel, xticks=xticks[ns_idx], ylabel="" if yticks[ns_idx] == False else ylabel, yticks=yticks[ns_idx], ax=ax, cbar=self.myc["cbar"][ns_idx], cbar_kw=myc["cbar_kw"], vmin=vmin, vmax=vmax, annotations=self.get_ann()[ns_idx], axis_setting=self.myc.get("axis_setting", "scaled"), ) ax.axis("tight") fig.savefig(file_name, dpi=300, transparent=True) plt.close(fig)