def plot_snr_image(img, ivm, levels=(-1.5, 1.5,)): img, imgext = parse_ext(img) ivm, ivmext = parse_ext(ivm) data = fits.getdata(img, ext=imgext) np.seterr(all='ignore') if 'ivm' in ivm or 'wh' in ivm or 'WHT' == ivmext: inv_noise = np.sqrt(fits.getdata(ivm, ext=ivmext)) elif 'rms' in ivm or 'sig' in ivm or 'ERR' == ivmext: inv_noise = 1.0 / fits.getdata(ivm, ext=ivmext) else: print('Unknown weight map format {}'.format(ivm)) return pp.figure() # Use linthresh=1 to go linear when we reach the sky noise norm = SymLogNorm(linthresh=1) pp.imshow(data * inv_noise, interpolation='nearest', origin='lower', norm=norm) cbar = pp.colorbar() ticks = norm.inverse(np.linspace(0, 1, 10)) cbar.set_ticks(ticks) cbar.set_label('S/N') if len(levels) > 0: pp.contour(data * inv_noise, levels=levels, colors='black') pp.title(img) pp.show()
def plot_residual_image(old_res, new_res, mode): nres = fits.getdata(new_res) ores = fits.getdata(old_res) cmap = 'hot' cnorm = SymLogNorm(linthresh=30, linscale=0.5) # # Zoomed out # fig = plt.figure(figsize=(10, 5)) ax1 = plt.subplot(121, aspect='equal') im = plt.imshow(ores, cmap=cmap, norm=cnorm) plt.title('Old ' + mode) plt.gca().invert_yaxis() plt.subplot(122, sharex=ax1, sharey=ax1, aspect='equal') plt.imshow(nres, cmap=cmap, norm=cnorm) plt.title('New ' + mode) plt.gca().invert_yaxis() plt.subplots_adjust(right=0.8) cbar_ax = fig.add_axes([0.85, 0.15, 0.05, 0.7]) fig.colorbar(im, cax=cbar_ax) # # Zoomed in. # c_pos = [500, 550] c_siz = [200, 200] nres_c = Cutout2D(nres, c_pos, c_siz) ores_c = Cutout2D(ores, c_pos, c_siz) cnorm = SymLogNorm(linthresh=30, linscale=0.5, vmin=nres_c.data.min(), vmax=nres_c.data.max()) fig2 = plt.figure(figsize=(10, 5)) ax2 = plt.subplot(121, aspect='equal') im = plt.imshow(ores_c.data, extent=np.array(ores_c.bbox_original)[::-1].flatten(), cmap=cmap, norm=cnorm) plt.title('Old ' + mode) plt.gca().invert_yaxis() plt.subplot(122, sharex=ax2, sharey=ax2, aspect='equal') plt.imshow(nres_c.data, extent=np.array(nres_c.bbox_original)[::-1].flatten(), cmap=cmap, norm=cnorm) plt.title('New ' + mode) plt.gca().invert_yaxis() plt.subplots_adjust(right=0.8) cbar_ax = fig2.add_axes([0.85, 0.15, 0.05, 0.7]) fig2.colorbar(im, cax=cbar_ax) plt.show() return
def plotFinalResults(entry, img, totalSuccess, profile, c_profiles, pRange, gimgMasked, gColumnTotalFine, contamGimg, wpa, subtractGimg, stageDir): '''for use after fully subtracting the contaminants''' gdx = gimgMasked.shape[1] gdy = gimgMasked.shape[0] xmin, xmax, ymin, ymax = max(entry['X_IMAGE']-gdx/2., 0), min(entry['X_IMAGE']+gdx/2., img.shape[1]-1), \ max(entry['Y_IMAGE']-gdy/2., 0), min(entry['Y_IMAGE']+gdy/2., img.shape[0]-1) f, ((directImagePlot, directImageProfilePlot), (grismPlot, grismProfilePlot), (contamPlot, contamProfilePlot), \ (subtractedPlot, subtractedProfilePlot)) = plt.subplots(4, 2, sharey=True) #plot a grism-sized piece of the direct image crop = img[ymin:ymax, xmin:xmax] directImagePlot.imshow(crop, norm=SymLogNorm(0.1)) if totalSuccess: directImagePlot.set_title('object %i' % entry['NUMBER']) else: directImagePlot.set_title('object %i (minimization unsuccessful)' % entry['NUMBER']) directImagePlot.set_ylabel('direct') directImagePlot.axis([0, gdx, 0, gdy]) directImageProfile = profile for profNum in c_profiles: directImageProfile += c_profiles[profNum] directImageProfilePlot.plot(directImageProfile, pRange) directImageProfilePlot.set_title('profiles') #plot the measured grism and its intensity profile vmin = np.ma.min(gimgMasked) vmax = np.ma.max(gimgMasked) grismPlot.imshow(gimgMasked, norm=SymLogNorm(0.1, vmin=vmin, vmax=vmax)) grismPlot.set_ylabel('grism') grismProfilePlot.plot(gColumnTotalFine, pRange) #plot the contamination model and its intensity profile contamPlot.imshow(contamGimg, norm=SymLogNorm(0.01)) contamPlot.set_ylabel('model') contamProfilePlot.plot(sum(wpa), pRange) #plot the subtracted grism and its intensity profile subtractedPlot.imshow(subtractGimg, norm=SymLogNorm(0.1, vmin=vmin, vmax=vmax)) subtractedPlot.set_ylabel('subtracted') subtractedProfile = np.ma.average(subtractGimg, axis=-1) subtractedProfilePlot.plot(subtractedProfile, xrange(gdy)) plt.savefig('%s/stages%i.png' % (stageDir, entry['NUMBER'])) plt.close(f) return
def plot_comp_forloop(data1, data2, varname, tstep, loga, savedir, var_min, var_max, dpi): data_var_t1 = data1[varname][tstep] data_var_t2 = data2[varname][tstep] var_t = data_var_t2 / data_var_t1 plt.figure() if loga == False: var_t.plot(vmin=var_min, vmax=var_max) if loga == True: var_t.plot(vmin=var_min, vmax=var_max, norm=SymLogNorm(vmin=var_min, vmax=var_max, linthresh=1e-8, linscale=1e-8)) plt.title(r"\textbf{Variable} " + str(varname) + r" \textbf{at }" + str(data1.coords['time'][tstep].values).zfill(9) + ' s') plt.axes().set_aspect('equal', 'datalim') plt.savefig(savedir + str(str(varname) + "_" + str(tstep).zfill(9) + ".png"), bbox_inches='tight', dpi=dpi) plt.close('all') return None
def plot_density(fignum, wave_title, wave): """ Plots density evolution of a wavefunction :param fignum: Tracks the figure number so plots may be rendered simultaneously :param wave_title: Name of equation used to predict wave; either GPE or Schrodinger :param wave: The propagating wavefunction :return: """ plt.figure(fignum) fignum += 1 title = wave_title + ' Evolution' # plt.title(title) plt.imshow( np.abs(wave)**2, # some plotting parameters origin='lower', extent=extent_units, aspect=aspect, norm=SymLogNorm(vmin=1e-8, vmax=1., linthresh=1e-15)) plt.xlabel('Position ($\mu$m)') plt.ylabel('Time (ms)') plt.colorbar() plt.tight_layout() plt.savefig(savespath + method + title + '.pdf') return fignum
def plot(PESmtx, ax, bar_val=True, label_val=True, color='RdYlBu'): cax = ax.imshow(PESmtx,cmap = color, vmin=-1.,vmax=1.,norm=SymLogNorm(10**-4),\ extent = [-3.14/2.,3.14/2.,-3.14,3.14]) fsize = 16 plt.xticks([-1.5, -.75, 0.0, .75, 1.5], ['-1.0', '-0.5', '0.0', '0.5', '1.0'], fontsize=fsize) plt.yticks([-3, -2, -1, 0, 1, 2, 3], ['-3', '-2', '-1', '0', '1', '2', '3'], fontsize=fsize) if label_val: xlab = r' $k ( a/ \pi )$' ylab = r'Energy / $\tau$' plt.xlabel(xlab, fontsize=fsize) plt.ylabel(ylab, fontsize=fsize) if bar_val: tick_labels = ['-0.500', '-0.005', '0.000', '0.005', '0.500'] tick_locs = [-0.50, -0.005, 0.00, 0.005, 0.50] bar = plt.colorbar(cax, ticks=tick_locs, shrink=0.6) bar.set_ticklabels(tick_labels) bar.update_ticks() return cax
def plot2d(result, calibrant=None, label=None, ax=None): """Display the caked image in the jupyter notebook :param result: instance of Integrate2dResult :param calibrant: Calibrant instance to overlay diffraction lines :param label: (str) name of the curve :param ax: subplot object to display in, if None, a new one is created. :return: Matplotlib subplot """ img = result.intensity pos_rad = result.radial pos_azim = result.azimuthal if ax is None: _fig, ax = subplots() colornorm = SymLogNorm(1, base=10, vmin=numpy.nanmin(img), vmax=numpy.nanmax(img)) ax.imshow( img, origin="lower", extent=[pos_rad.min(), pos_rad.max(), pos_azim.min(), pos_azim.max()], aspect="auto", cmap="inferno", norm=colornorm) if label: ax.set_title("2D regrouping") else: ax.set_title(label) ax.set_xlabel(result.unit.label) ax.set_ylabel(r"Azimuthal angle $\chi$ ($^{o}$)") if calibrant: from pyFAI import units x_values = None twotheta = numpy.array([i for i in calibrant.get_2th() if i]) # in radian unit = result.unit if unit == units.TTH_DEG: x_values = numpy.rad2deg(twotheta) elif unit == units.TTH_RAD: x_values = twotheta elif unit == units.Q_A: x_values = (4.e-10 * numpy.pi / calibrant.wavelength) * numpy.sin( .5 * twotheta) elif unit == units.Q_NM: x_values = (4.e-9 * numpy.pi / calibrant.wavelength) * numpy.sin( .5 * twotheta) if x_values is not None: for x in x_values: line = lines.Line2D( [x, x], [pos_azim.min(), pos_azim.max()], color='red', linestyle='--') ax.add_line(line) return ax
def main(): get_file = lambda x: "cru_ts3.23.1901.2014.{0}.100mean.pkl".format(x) tair_data = pickle.load(open(FILEPATH + get_file('tmp'), 'rb')) rain_data = pickle.load(open(FILEPATH + get_file('pre'), 'rb')) sav_patch = pickle.load(open(PATCHPATH, 'rb')) fig = plt.figure(figsize=(10, 6), frameon=False) fig.add_axes([0, 0, 1.0, 1.0]) n_plots = 2 grid = gridspec.GridSpec(n_plots, 1, hspace=0.3) subaxs = [plt.subplot(grid[i]) for i in range(n_plots)] # Mean Annual Temperature plot make_map(subaxs[0], tair_data, sav_patch['clip'], \ cmap=get_cmap(MAPCOLOR), \ levels=np.arange(15, 35, 0.5), \ cticks=np.arange(15, 35, 2.5), \ title="Global Savanna Bioregion \\\\ Mean Annual Temperature (1901 to 2013)") # Mean Annual Rainfall plot make_map(subaxs[1], rain_data, sav_patch['clip'], \ cmap=get_cmap(MAPCOLOR), \ levels=np.logspace(1, 3, 100), \ cticks=[10, 50, 100, 200, 500, 1000], \ norm=SymLogNorm(linthresh=0.3, linscale=0.03), \ title="Global Savanna Bioregion \\\\ Mean Annual Precipitation (1901 - 2013)") plt.savefig(SAVEPATH)
def nice_map(wl, t, d, lvls=20, linthresh=10, linscale=1, norm=None, linscaley=1, cmap='coolwarm', **kwargs): if norm is None: norm = SymLogNorm(linthresh, linscale=linscale) con = plt.contourf(wl, t, d, lvls, norm=norm, cmap=cmap, **kwargs) cb = plt.colorbar(pad=0.02) cb.set_label(sig_label) plt.contour(wl, t, d, lvls, norm=norm, colors='black', lw=.5, linestyles='solid') plt.yscale('symlog', linthreshy=1, linscaley=linscaley, suby=[2, 3, 4, 5, 6, 7, 8, 9]) plt.ylim(-.5, ) plt.xlabel(freq_label) plt.ylabel(time_label) return con
def dependencies(deps: DependencyResult, model_output: int = None, *, cmap="RdBu_r", fontcolor_thresh: float = None, text_len: int = None, omit_leading_zero: bool = None, trailing_zeros: bool = None, grid: bool = None, angle_left: bool = None, cbar: bool = None, cbar_label: str = None, ax: plt.Axes = None, figsize: Tuple[float, float] = None, cellsize: float = None, title: str = None): if model_output is None and deps.data.ndim != 2: n_model_outputs = deps.data.shape[2] if n_model_outputs != 1: raise ValueError("When plotting dependencies, the model_output argument can only be omitted when " "there is only one model output in the DependencyResult. However, this Dependency " f"stores {n_model_outputs} model outputs. So, please supply model_output.") else: model_output = 0 plot_kwargs = { "cmap": cmap, "fontcolor_thresh": fontcolor_thresh, "text_len": text_len, "omit_leading_zero": omit_leading_zero, "trailing_zeros": trailing_zeros, "grid": grid, "angle_left": angle_left, "cbar": cbar, "cbar_label": cbar_label, "ax": ax, "figsize": figsize, "cellsize": cellsize, "title": title} plot_kwargs = {k: v for k, v in plot_kwargs.items() if v is not None} if model_output is None: values = deps.data else: values = deps.data[:, :, model_output] labels = [f"{type(om).__name__[0]}~{frag}" for om, frag in deps.reverse_index] extremum = max(1, nan_op(np.ma.max, np.abs(values))) plot_matrix(values, row_labels=labels, col_labels=labels, norm=SymLogNorm(linthresh=0.1, linscale=0.2, vmin=-extremum, vmax=extremum), **plot_kwargs)
def norm(self, norm): vmin, vmax = self.pixels.norm.vmin, self.pixels.norm.vmax if norm == "lin": self.pixels.norm = Normalize() elif norm == "log": vmin = 0.1 if vmin < 0 else vmin vmax = 0.2 if vmax < 0 else vmax self.pixels.norm = LogNorm(vmin=vmin, vmax=vmax) self.pixels.autoscale() # this is to handle matplotlib bug #5424 elif norm == "symlog": self.pixels.norm = SymLogNorm(linthresh=1.0, base=10, vmin=vmin, vmax=vmax) self.pixels.autoscale() elif isinstance(norm, Normalize): self.pixels.norm = norm else: raise ValueError( "Unsupported norm: '{}', options are 'lin'," "'log','symlog', or a matplotlib Normalize object".format( norm)) self.update() self.pixels.autoscale()
def plot_heatmap_corridor(plotdata, c, unit, figsize=(15, 12), cmap='Blues', vmin=None, vmax=None): if unit == 'mln': plotdata = plotdata / 1e6 c = c.replace('(', '(mln ') elif unit == '1000': plotdata = plotdata / 1e3 c = c.replace('(', '(x1000 ') if plotdata.abs().max().max() > 100: format = '.0f' else: format = '.1f' f, ax = plt.subplots(figsize=figsize) sns.heatmap(plotdata.T, cmap=cmap, annot=True, fmt=format, ax=ax, norm=SymLogNorm(1), cbar=False, vmin=vmin, vmax=vmax) plt.xlabel('Herkomst') plt.ylabel('Bestemming') plt.title(f'{c} - {scenarios.Qref}')
def get_norm(self): """ This will create a matplotlib.colors.Normalize from selected idx, limits and powerscale """ idx = self.norm.currentIndex() if self.autoscale.isChecked(): cmin = cmax = None else: cmin = self.cmin_value cmax = self.cmax_value if NORM_OPTS[idx] == 'Power': if self.powerscale.hasAcceptableInput(): self.powerscale_value = float(self.powerscale.text()) return PowerNorm(gamma=self.powerscale_value, vmin=cmin, vmax=cmax) elif NORM_OPTS[idx] == "SymmetricLog10": return SymLogNorm( 1e-8 if cmin is None else max(1e-8, abs(cmin) * 1e-3), vmin=cmin, vmax=cmax) elif NORM_OPTS[idx] == "Log": cmin = MIN_LOG_VALUE if cmin is not None and cmin <= 0 else cmin return LogNorm(vmin=cmin, vmax=cmax) else: return Normalize(vmin=cmin, vmax=cmax)
def plot_mosaic(mosaic, outfile, node_ranks, coarsen): """ Given a mosaic, plot it to outfile. """ cmap = cm.plasma_r cmap.set_under(color="white") if not isinstance(mosaic, np.ndarray): M = mosaic_to_mat(mosaic, SHIFT) else: M = mosaic if (np.amin(M) < 0): plt.matshow(M, cmap="RdBu_r", norm=SymLogNorm(linthresh=SHIFT)) else: plt.matshow(M, cmap=cmap, norm=LogNorm(vmin=vmin(M, 10 * SHIFT))) plt.colorbar() plt.xlabel("Destination") plt.ylabel("Source") if not coarsen: ax = plt.gca() ax.xaxis.set_major_locator(MultipleLocator(node_ranks)) ax.yaxis.set_major_locator(MultipleLocator(node_ranks)) plt.grid(True, color="black") plt.savefig(outfile)
def plotHeatmapInLogarithmicScaleFromFigAxAndData(fig, ax, np_data, colorbar_limit_min, colorbar_limit_max, linthresh, colormap): # Logarithmic scale heatmap = ax.pcolor(np_data, cmap=colormap, norm=SymLogNorm(vmin=colorbar_limit_min, vmax=colorbar_limit_max, linthresh=linthresh)) # heatmap = ax.pcolor(np_data, norm=SymLogNorm(vmin=colorbar_limit_min, vmax=colorbar_limit_max,linthresh=linthresh)) # The ticks of the colorbar are all powers of 10 and also the min and the max of the heatmap colorbar_ticks = list( set( exponentialRangeFromMinAndMax(colorbar_limit_min, colorbar_limit_max) + [colorbar_limit_min, colorbar_limit_max]) ) # list(set(...)) so the duplicates are eliminated cbar = fig.colorbar( heatmap, ticks=colorbar_ticks, format=matplotlib.ticker.FuncFormatter( lambda x, p: logTickerToString(x, p)) ) # I create a lambda instead of just putting the function name so it's more explicit that it's a function and that it receives x and p # Change font size in color bar cbar.ax.tick_params(labelsize=10)
def test_that_masked_data_in_symmetric_log_mode_will_cause_a_switch_back_to_linear_normalisation( self): image = plt.imshow(self.data, cmap="plasma", norm=SymLogNorm(1e-8, vmin=0.01, vmax=1.0)) masked_image = plt.imshow(self.masked_data, cmap="plasma", norm=SymLogNorm(1e-8, vmin=0.01, vmax=1.0)) self.widget.set_mappable(image) self.widget.norm.setCurrentIndex(NORM_OPTS.index("SymmetricLog10")) self.widget.set_mappable(masked_image) self.assertEqual(self.widget.norm.currentIndex(), NORM_OPTS.index("Linear")) self.assertTrue(isinstance(masked_image.norm, Normalize))
def plot_snapshots(Hs, flowparams, delta, g): fig = plt.figure(1, (10., 5.)) grid = AxesGrid( fig, 111, # similar to subplot(111) nrows_ncols=(2, int(Hs.shape[0] / 2)), # creates grid of axes axes_pad=0.25, # pad between axes in inch. label_mode='L', # put labels on left, bottom cbar_mode= 'single', # one color bar (default: right of last image in grid) cbar_pad=0.20, # insert space between plots and color bar cbar_size='10%' # size of colorbar relative to last image ) # create individual snapshots - figures are still addressed by single index, # despite multi-row grid Hmin = -0.5 * g Hmax = 10 * delta for s in range(Hs.shape[0]): img = grid[s].imshow( Hs[s], cmap=plt.get_cmap('RdBu_r'), # choose color map interpolation='nearest', norm=SymLogNorm(linthresh=1e-10, vmin=Hmin, vmax=Hmax), # normalize vmin=Hmin, # min/max values for data vmax=Hmax) # tune plots: switch off tick marks, ensure that plots retain aspect ratio grid[s].set_title('$s=%s$' % flowparams[s]) grid[s].tick_params(bottom='off', top='off', left='off', right='off') grid[s].set_xticks([0, 1, 2, 3, 4, 5]) grid[s].set_yticks([0, 1, 2, 3, 4, 5]) grid[s].set_xticklabels(['$0$', '$1$', '$2$', '$3$', '$4$', '$5$']) grid[s].set_yticklabels(['$0$', '$1$', '$2$', '$3$', '$4$', '$5$']) cbar = grid.cbar_axes[0] plt.colorbar(img, cax=cbar, ticks=[ -1.0e-1, -1.0e-3, -1.0e-5, -1.0e-7, -1.09e-9, 0., 1.0e-9, 1.0e-7, 1.0e-5, 1.0e-3, 0.1, 10.0 ]) cbar.axes.set_yticklabels([ '$-10^{-1}$', '$-10^{-3}$', '$-10^{-5}$', '$-10^{-7}$', '$-10^{-9}$', '$0.0$', '$10^{-9}$', '$10^{-7}$', '$10^{-5}$', '$10^{-3}$', '$10^{-1}$', '$10$' ]) cbar.set_ylabel('$\mathrm{[a. u.]}$') plt.savefig("srg_pairing_delta%2.1f_g%2.1f.pdf" % (delta, g), bbox_inches="tight", pad_inches=0.05) plt.show() return
def cmap_norm_ticks(a, whatpercentiles=[1, 99], howmanysigmaarelinear=1.5, whatfractionislinear=0.15, vmax=None, vmin=None, cmap=None): ''' Return a probably pretty-OK colormap, a color normalization, and suggested tick marks for a colorbar, based on an input array. Parameters ---------- a : array The cmap and norm will be set on the basis of values in this array. ''' if vmin is None: gonegative = (a <= 0).any() else: gonegative = vmin < 0 # figure out a decent color scale if gonegative: # go diverging, if this is a difference that crosses zero if vmax is not None: vmin = -vmax else: vmin, vmax = np.nanpercentile(a, whatpercentiles) scale = np.maximum(np.abs(vmin), np.abs(vmax)) vmin, vmax = -scale, scale span = np.log10(vmax) sigma = mad(a) norm = SymLogNorm(howmanysigmaarelinear * sigma, linscale=span * whatfractionislinear, vmin=vmin, vmax=vmax) if cmap is None: cmap = 'RdBu' ticks = [ vmin, -howmanysigmaarelinear * sigma, 0, howmanysigmaarelinear * sigma, vmax ] else: if vmax is None: vmax = np.nanpercentile(a, whatpercentiles[1]) if vmin is None: vmin = np.nanpercentile(a, whatpercentiles[0]) # go simple logarithmic, if this is all positive norm = LogNorm(vmin=vmin, vmax=vmax) if cmap is None: cmap = 'Blues' ticks = [vmin, vmin * np.sqrt(vmax / vmin), vmax] return cmap, norm, ticks
def plot_detector_image(input_workspace: EventWorkspace, fig, ax): plot = ax.imshow(input_workspace, aspect='auto', cmap='viridis', distribution=True, origin='lower', norm=SymLogNorm(1e-6)) fig.colorbar(plot, ax=ax) ax.set_title("Detector image")
def plotpolarimg(data, cmap, INVERT): if INVERT == True: plt.figure() plt.imshow(data, cmap=cmap, extent=[0, 20000, 60, 0], aspect='auto', norm=SymLogNorm(linthresh=3e-02, vmin=-1, vmax=1)) plt.gca().invert_yaxis() elif INVERT == False: plt.figure() plt.imshow(data, cmap=cmap, extent=[0, 20000, 60, 0], aspect='auto', norm=SymLogNorm(linthresh=3e-02, vmin=-1, vmax=1)) plt.ylabel('angle theta') plt.xlabel('radius from transducer')
def test_vmin_vmax_api(test_data_dir, temp_figure_and_axis): ds = GasDataSet(1, directory=test_data_dir / "idefix_rwi", geometry="polar") fig, ax = temp_figure_and_axis p = ds["VX1"].vertical_at_midplane().map("R", "phi") # check that no warning is emitted from matplotlib im1 = p.plot(fig, ax, vmin=-1, vmax=1, norm=SymLogNorm(linthresh=0.1, base=10)) im2 = p.plot(fig, ax, norm=SymLogNorm(linthresh=0.1, base=10, vmin=-1, vmax=1)) npt.assert_array_equal(im1.get_array(), im2.get_array())
def plot_embedding(spec, path): spec = spec.transpose(1, 0) # (seq_len, feature_dim) -> (feature_dim, seq_len) plt.gcf().clear() plt.figure(figsize=(12, 3)) plt.pcolormesh(spec, norm=SymLogNorm(linthresh=1e-3)) plt.colorbar() plt.tight_layout() plt.savefig(path, dpi=300, format="png") plt.close()
def test_log_symlognorm_cbar(): # test the undesired minor ticks do not appear if minor # ticks visibility is set to True for a pcolormesh with # a SymLogNorm data = [[0.0001, 0.005], [0.01, 1]] plt.rcParams['xtick.minor.visible'] = True plt.rcParams['ytick.minor.visible'] = True plt.pcolormesh(data, norm=SymLogNorm(0.01)) plt.colorbar()
def plot_bg_full(b, gx, gy): fig = plt.figure(figsize=[20,20]) ax = fig.gca() lt = 5 mm = apply_geom_ij_yx( (gy,gx), ~b.bl.mask ) bb = apply_geom_ij_yx( (gy,gx), b.bl) bb = np.ma.masked_array(bb, ~mm) ax.matshow(bb, vmin=-0.15*64, norm=SymLogNorm(0.15*64,lt, base=10)) ax.set_xticks([]) ax.set_yticks([])
def log_changed(self, value): p = self._cur_plot if p is not None and p.ax.images: old = p.ax.images[0].norm kw = dict(vmin=old.vmin, vmax=old.vmax, clip=old.clip) if value: n = SymLogNorm(1e-9, **kw) else: n = Normalize(**kw) p.ax.images[-1].norm = n p.update()
def xm_ploting(var_t, ticks, var_max, var_min, varname, var_time, var_tstp, save=False, savefile=False, loga=False, title=True): plt.figure() if loga == False: fig = var_t.plot(vmin=var_min, vmax=var_max) elif loga == True: fig = var_t.plot(norm=SymLogNorm(vmin=var_min, vmax=var_max, linthresh=1e-9, linscale=1e-9), cbar_kwargs={ 'ticks': ticks, 'format': ticker.FuncFormatter(fmt) }) if title == True: if var_time == 0.0 and var_tstp != 0: plt.title(r"\textbf{Variable} " + str(varname) + r" \textbf{at }" + str(var_tstp).zfill(9) + ' timesteps') else: plt.title(r"\textbf{Variable} " + str(varname) + r" \textbf{at }" + str(var_time).zfill(6) + ' s') else: plt.title(' ') plt.axes().set_aspect('equal', 'datalim') plt.xlabel(r'x [m]') plt.ylabel(r'y [m]') if save == True: if savefile == False: plt.savefig( str(str(varname) + "_" + str(var_tstp).zfill(9) + ".png"), bbox_inches='tight', dpi=300) # saving figure else: plt.savefig(savefile, bbox_inches='tight', dpi=300) # saving figure elif save == False: plt.show() return None
def convolve_im(im: np.array, fft_kernel: np.array, verbose=True): """ Convolves the image (im) with the frequency kernel (fft_kernel), and returns the resulting image. "verbose" can be used for turning on/off visualization convolution Args: im: np.array of shape [H, W] fft_kernel: np.array of shape [H, W] verbose: bool Returns: im: np.array of shape [H, W] """ # START YOUR CODE HERE ### (You can change anything inside this block) fft = np.fft.fft2(im) prod = fft * fft_kernel conv_result = np.abs(np.fft.ifft2(prod)) if verbose: # Use plt.subplot to place two or more images beside eachother plt.figure(figsize=(20, 4)) # plt.subplot(num_rows, num_cols, position (1-indexed)) plt.subplot(2, 3, 1) plt.imshow(im, cmap="gray") plt.subplot(2, 3, 2) plt.imshow(np.abs(np.fft.fftshift(fft)), cmap="gray", norm=SymLogNorm(1)) plt.subplot(2, 3, 4) plt.imshow(np.abs(np.fft.fftshift(fft_kernel)), cmap="gray", norm=SymLogNorm(1)) plt.subplot(2, 3, 5) plt.imshow(np.abs(np.fft.fftshift(prod)), cmap="gray", norm=SymLogNorm(1e-3)) plt.subplot(2, 3, 6) plt.imshow(conv_result, cmap="gray") ### END YOUR CODE HERE ### return conv_result
def ctamap( obs , emin , emax , \ coordsys , ra , dec , rad , \ caldb , irf , name , plotfile ) : skymap = ctools.ctskymap() skymap[ 'inobs' ] = obs skymap[ 'emin' ] = emin skymap[ 'emax' ] = emax skymap[ 'nxpix' ] = 100 skymap[ 'nypix' ] = 100 skymap[ 'binsz' ] = 0.02 skymap[ 'proj' ] = 'CAR' skymap[ 'coordsys' ] = coordsys skymap[ 'xref' ] = ra skymap[ 'yref' ] = dec skymap[ 'bkgsubtract' ] = 'IRF' skymap[ 'caldb' ] = caldb skymap[ 'irf' ] = irf skymap[ 'outmap' ] = name skymap.execute() skymap.skymap().smooth( 'GAUSSIAN', 0.02 ) ax = plt.subplot() plt.imshow( skymap.skymap().array() , \ origin='lower' , \ extent=[ ra + rad , \ ra - rad , \ dec - rad , \ dec + rad ] , \ norm=SymLogNorm( 1 , base=10 ) ) xlabel = '' ; ylabel = '' ; if coordsys == 'GAL' : xlabel = 'Longitude (deg)' ylabel = 'Latitude (deg)' elif coordsys == 'CEL' : xlabel = 'R.A. (deg)' ylabel = 'DEC (deg)' else : print( 'Unknown coordinate System. \ I will assume Celestial Coordinate System' ) xlabel = 'R.A. (deg)' ylabel = 'DEC (deg)' ax.set_xlabel( xlabel ) ax.set_ylabel( ylabel ) cbar = plt.colorbar() cbar.set_label( 'Counts' ) if len( plotfile ) > 0 : plt.savefig( plotfile ) else : plt.show() plt.close()
def plot_matrix(self) -> plt.Figure: fig, ax = plt.subplots() idx_mc = 0 idx_eb = 0 # Some times the lower edges may be zero, so we skip them if self._mc_energies[0] == 0: idx_mc = 1 if self._ebounds[0] == 0: idx_eb = 1 # ax.imshow(image[idx_eb:, idx_mc:], extent=(self._ebounds[idx_eb], # self._ebounds[-1], # self._mc_energies[idx_mc], # self._mc_energies[-1]), # aspect='equal', # cmap=cm.BrBG_r, # origin='lower', # norm=SymLogNorm(1.0, 1.0, vmin=self._matrix.min(), vmax=self._matrix.max())) # Find minimum non-zero element vmin = self._matrix[self._matrix > 0].min() cmap = copy.deepcopy( cm.get_cmap(threeML_config.plugins.ogip.response_cmap.value)) cmap.set_under(threeML_config.plugins.ogip.response_zero_color) mappable = ax.pcolormesh( self._mc_energies[idx_mc:], self._ebounds[idx_eb:], self._matrix, cmap=cmap, norm=SymLogNorm(1.0, 1.0, vmin=vmin, vmax=self._matrix.max()), ) ax.set_xscale("log") ax.set_yscale("log") fig.colorbar(mappable, label="cm$^{2}$") # if show_energy is not None: # ener_val = Quantity(show_energy).to(self.reco_energy.unit).value # ax.hlines(ener_val, 0, 200200, linestyles='dashed') ax.set_xlabel("True energy (keV)") ax.set_ylabel("Reco energy (keV)") return fig
def grheat(X, gridbounds, xlabel=None, ylabel=None, zlabel=None): """Simple interface to a heatmap (uses matplotlib's `imshow`). Parameters ---------- X : numpy.array a matrix-like object gridbounds : float or tuple the bounds of the grid. If a float, -/+ this value is taken as the bounds xlabel : str (optional) ylabel : str (optional) zlabel : str (optional) """ fig, ax = plt.subplots() if isinstance(gridbounds, tuple): if isinstance(gridbounds[0], tuple): extent = [ *gridbounds[0], *gridbounds[1], ] else: extent = [ -gridbounds[0], gridbounds[0], -gridbounds[1], gridbounds[1], ] else: extent = [ -gridbounds, gridbounds, -gridbounds, gridbounds, ] plt.imshow(X, cmap="hot", extent=extent, vmin=np.nanmin(X), vmax=np.nanmax(X), norm=SymLogNorm(1, linscale=1)) clb = plt.colorbar() plt.xlabel(xlabel) plt.ylabel(ylabel) plt.grid(False) clb.set_label(zlabel) plt.tight_layout()
def plotimg(data, cmap, z, zact, INVERT): if INVERT == True: plt.figure() plt.imshow(data, cmap=cmap, extent=[zact - z, zact, z / np.sqrt(3), -z / np.sqrt(3)], aspect='auto', norm=SymLogNorm(linthresh=0.01, vmin=np.amin(data), vmax=np.amax(data))) plt.gca().invert_yaxis() elif INVERT == False: plt.figure() plt.imshow(data, cmap=cmap, extent=[zact - z, zact, -z / np.sqrt(3), z / np.sqrt(3)], aspect='auto', norm=SymLogNorm(linthresh=0.01, vmin=np.amin(data), vmax=np.amax(data))) plt.xlabel('mm in z-direction') plt.ylabel('mm in x-direction')