def test_Bug_2543(): # Test that it possible to add all values to itself / deepcopy # This was not possible because validate_bool_maybe_none did not # accept None as an argument. # https://github.com/matplotlib/matplotlib/issues/2543 # We filter warnings at this stage since a number of them are raised # for deprecated rcparams as they should. We dont want these in the # printed in the test suite. with warnings.catch_warnings(): warnings.filterwarnings('ignore', message='.*(deprecated|obsolete)', category=UserWarning) with mpl.rc_context(): _copy = mpl.rcParams.copy() for key in six.iterkeys(_copy): mpl.rcParams[key] = _copy[key] mpl.rcParams['text.dvipnghack'] = None with mpl.rc_context(): from copy import deepcopy _deep_copy = deepcopy(mpl.rcParams) # real test is that this does not raise assert_true(validate_bool_maybe_none(None) is None) assert_true(validate_bool_maybe_none("none") is None) _fonttype = mpl.rcParams['svg.fonttype'] assert_true(_fonttype == mpl.rcParams['svg.embed_char_paths']) with mpl.rc_context(): mpl.rcParams['svg.embed_char_paths'] = False assert_true(mpl.rcParams['svg.fonttype'] == "none")
def test_rcparams(): mpl.rc('text', usetex=False) mpl.rc('lines', linewidth=22) usetex = mpl.rcParams['text.usetex'] linewidth = mpl.rcParams['lines.linewidth'] fname = os.path.join(os.path.dirname(__file__), 'test_rcparams.rc') # test context given dictionary with mpl.rc_context(rc={'text.usetex': not usetex}): assert mpl.rcParams['text.usetex'] == (not usetex) assert mpl.rcParams['text.usetex'] == usetex # test context given filename (mpl.rc sets linewidth to 33) with mpl.rc_context(fname=fname): assert mpl.rcParams['lines.linewidth'] == 33 assert mpl.rcParams['lines.linewidth'] == linewidth # test context given filename and dictionary with mpl.rc_context(fname=fname, rc={'lines.linewidth': 44}): assert mpl.rcParams['lines.linewidth'] == 44 assert mpl.rcParams['lines.linewidth'] == linewidth # test rc_file mpl.rc_file(fname) assert mpl.rcParams['lines.linewidth'] == 33
def test_rcparams(): usetex = mpl.rcParams['text.usetex'] linewidth = mpl.rcParams['lines.linewidth'] # test context given dictionary with mpl.rc_context(rc={'text.usetex': not usetex}): assert mpl.rcParams['text.usetex'] == (not usetex) assert mpl.rcParams['text.usetex'] == usetex # test context given filename (mpl.rc sets linewdith to 33) with mpl.rc_context(fname=fname): assert mpl.rcParams['lines.linewidth'] == 33 assert mpl.rcParams['lines.linewidth'] == linewidth # test context given filename and dictionary with mpl.rc_context(fname=fname, rc={'lines.linewidth': 44}): assert mpl.rcParams['lines.linewidth'] == 44 assert mpl.rcParams['lines.linewidth'] == linewidth # test rc_file try: mpl.rc_file(fname) assert mpl.rcParams['lines.linewidth'] == 33 finally: mpl.rcParams['lines.linewidth'] = linewidth
def test_Bug_2543(): # Test that it possible to add all values to itself / deepcopy # This was not possible because validate_bool_maybe_none did not # accept None as an argument. # https://github.com/matplotlib/matplotlib/issues/2543 # We filter warnings at this stage since a number of them are raised # for deprecated rcparams as they should. We don't want these in the # printed in the test suite. with warnings.catch_warnings(): warnings.filterwarnings('ignore', category=MatplotlibDeprecationWarning) with mpl.rc_context(): _copy = mpl.rcParams.copy() for key in _copy: mpl.rcParams[key] = _copy[key] with mpl.rc_context(): _deep_copy = copy.deepcopy(mpl.rcParams) # real test is that this does not raise assert validate_bool_maybe_none(None) is None assert validate_bool_maybe_none("none") is None with pytest.raises(ValueError): validate_bool_maybe_none("blah") with pytest.raises(ValueError): validate_bool(None) with pytest.raises(ValueError): with mpl.rc_context(): mpl.rcParams['svg.fonttype'] = True
def test_to_string(self): # test without latex with rc_context(rc={'text.usetex': False}): assert to_string('test') == 'test' assert to_string(4.0) == '4.0' assert to_string(8) == '8' with rc_context(rc={'text.usetex': True}): assert to_string('test') == 'test' assert to_string(2000) == r'2\!\!\times\!\!10^{3}' assert to_string(8) == '8'
def test_rcparams_reset_after_fail(): # There was previously a bug that meant that if rc_context failed and # raised an exception due to issues in the supplied rc parameters, the # global rc parameters were left in a modified state. with mpl.rc_context(rc={'text.usetex': False}): assert mpl.rcParams['text.usetex'] is False with assert_raises(KeyError): with mpl.rc_context(rc=OrderedDict([('text.usetex', True),('test.blah', True)])): pass assert mpl.rcParams['text.usetex'] is False
def test_jpeg_alpha(): Image = pytest.importorskip('PIL.Image') plt.figure(figsize=(1, 1), dpi=300) # Create an image that is all black, with a gradient from 0-1 in # the alpha channel from left to right. im = np.zeros((300, 300, 4), dtype=float) im[..., 3] = np.linspace(0.0, 1.0, 300) plt.figimage(im) buff = io.BytesIO() with rc_context({'savefig.facecolor': 'red'}): plt.savefig(buff, transparent=True, format='jpg', dpi=300) buff.seek(0) image = Image.open(buff) # If this fails, there will be only one color (all black). If this # is working, we should have all 256 shades of grey represented. num_colors = len(image.getcolors(256)) assert 175 <= num_colors <= 185 # The fully transparent part should be red. corner_pixel = image.getpixel((0, 0)) assert corner_pixel == (254, 0, 0)
def style(self): if self.rc_context is None: return EmptyContext() elif type(self.rc_context) is dict: return mpl.rc_context(self.rc_context) else: return self.rc_context
def plot_phase(self, rcParams={}): if not hasattr(self, 'phi_lock_phase'): raise ValueError("set_filters before plotting phase") rcParams_ = self.rcParams rcParams_.update(rcParams) with mpl.rc_context(rcParams_): fig, ax = plt.subplots() phase = np.angle(self.phi_lock) ax.plot(self.tm, phase[self.m]) if hasattr(self, 'phase'): adjusted_phase = phase_err(self.phase - phase) ax.plot(self.tm, (phase + adjusted_phase)[self.m]) if hasattr(self, 'm_fit'): ax.axvspan(np.min(self.t[self.m_fit]), np.max(self.t[self.m_fit]), alpha=0.5, color='0.5') ax.set_xlabel('Time [s]') ax.set_ylabel('Phase [rad.]') return fig, ax
def plot_simple(x, y, magic=None, scale='linear', xlim=None, ylim=None, xlabel=None, ylabel=None, figax=None, rcParams={'backend': 'Qt4Agg'}, **plot_kwargs): if figax is not None: fig, ax = figax else: with mpl.rc_context(rc=rcParams): fig = plt.figure() ax = fig.add_subplot(111) plotting_functions = { 'linear': ax.plot, 'semilogy': ax.semilogy, 'semilogx': ax.semilogx, 'loglog': ax.loglog} if magic is None: plotting_functions[scale](x, y, **plot_kwargs) else: plotting_functions[scale](x, y, magic, **plot_kwargs) if xlabel is not None: ax.set_xlabel(xlabel) if ylabel is not None: ax.set_ylabel(ylabel) if xlim is not None: ax.set_xlim(xlim) if ylim is not None: ax.set_ylim(ylim) return fig, ax
def plot_roc(self): """ Plot receiver operating charactistic curve for this subject's classifier. """ fpr, tpr, _ = roc_curve(self.res['y'], self.res['probs']) with plt.style.context('fivethirtyeight'): with mpl.rc_context({'ytick.labelsize': 16, 'xtick.labelsize': 16}): plt.plot(fpr, tpr, lw=4, label='ROC curve (AUC = %0.2f)' % self.res['auc']) plt.plot([0, 1], [0, 1], color='k', lw=2, linestyle='--', label='_nolegend_') plt.xlim([0.0, 1.0]) plt.ylim([0.0, 1.05]) plt.xlabel('False Positive Rate', fontsize=24) plt.ylabel('True Positive Rate', fontsize=24) plt.legend(loc="lower right") if 'p_val' not in self.res: title = 'ROC (AUC: {0:.3f})'.format(self.res['auc']) else: p = self.res['p_val'] if p == 0: p_str = '< {0:.2f}'.format(1 / self.num_iters) else: p_str = '= {0:.3f}'.format(p) title = 'ROC (AUC: {0:.3f}, p{1})'.format(self.res['auc'], p_str) plt.title(title) plt.gcf().set_size_inches(12, 9)
def demo(ax, rcparams, title): np.random.seed(2) A = np.random.rand(5, 5) with mpl.rc_context(rc=rcparams): ax.imshow(A) ax.set_title(title)
def __init__(self, port, baud, check = False): """ Initialize the main display: a single figure :port: serial port index or name (eg.: COM4) :paud: baud rate (eg.: 115200) """ self.frame = IM_Frame() self.new_frame = False self.lock = threading.Lock() self.check = check # disable figure toolbar, bind close event and open serial port with mpl.rc_context({'toolbar':False}): self.fig = plt.figure() self.serial_port = serial.Serial(port, baud, timeout=0.25,bytesize=serial.EIGHTBITS, parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE, xonxoff=False) self.serial_port.flush() self.fig.canvas.mpl_connect('close_event', self.close_display) self.fig.canvas.mpl_connect('resize_event', self.resize_display) self.fig.canvas.set_window_title('pyIM') # window position is set before state to maximized in update_graph w,h=getVirtualScreenSize() plt.get_current_fig_manager().window.wm_geometry(("+%d+%d"%(w-1,0))) # create timer for updating display using a rs232 polling callback timer = self.fig.canvas.new_timer(interval=250) timer.add_callback(self.update_graphs) # then arg if needed timer.start() # launch figure plt.show(block = True) # close correctly serial port self.close_display()
def test_hist(self, table): with rc_context(rc={'text.usetex': False}): plot = table.hist('snr') assert isinstance(plot, HistogramPlot) assert len(plot.gca().patches) == 10 with tempfile.NamedTemporaryFile(suffix='.png') as f: plot.save(f.name)
def plot_phasekick_corrected(df, extras, figax=None, rcParams={}, filename=None): if figax is None: with mpl.rc_context(rcParams): fig, ax = plt.subplots() else: fig, ax = figax data = df.loc['data'] control = df.loc['control'] if abs(data['dphi_corrected [cyc]']).max() > 0.15: units = 'cyc' scale = 1 else: units = 'mcyc' scale = 1e3 ax.plot(control.tp*1e3, control['dphi_corrected [cyc]']*scale, 'g.') ax.plot(data.tp*1e3, data['dphi_corrected [cyc]']*scale, 'b.') ax.plot(data.tp*1e3, phase_step(data.tp, *extras['popt_phase_corr'])*scale) ax.set_xlabel('Pulse time [ms]') ax.set_ylabel('Phase shift [{}.]'.format(units)) if filename is not None: fig.savefig(filename, bbox_inches='tight') return fig, ax
def test_LogFormatterSciNotation(): test_cases = { 10: ( (-1, '${-10^{0}}$'), (1e-05, '${10^{-5}}$'), (1, '${10^{0}}$'), (100000, '${10^{5}}$'), (2e-05, '${2\\times10^{-5}}$'), (2, '${2\\times10^{0}}$'), (200000, '${2\\times10^{5}}$'), (5e-05, '${5\\times10^{-5}}$'), (5, '${5\\times10^{0}}$'), (500000, '${5\\times10^{5}}$'), ), 2: ( (0.03125, '${2^{-5}}$'), (1, '${2^{0}}$'), (32, '${2^{5}}$'), (0.0375, '${1.2\\times2^{-5}}$'), (1.2, '${1.2\\times2^{0}}$'), (38.4, '${1.2\\times2^{5}}$'), ) } for base in test_cases.keys(): formatter = mticker.LogFormatterSciNotation(base=base) formatter.sublabel = set([1, 2, 5, 1.2]) for value, expected in test_cases[base]: with matplotlib.rc_context({'text.usetex': False}): assert formatter(value) == expected
def __init__(self, data, layout=(1, 1)): self._data = data self._layout = layout self._number_of_plots = len(data) self._plots_per_page = _numpy.product(layout) self._number_of_pages = (self._number_of_plots-1) / self._plots_per_page + 1 self._current_page = 0 with _matplotlib.rc_context({"toolbar": "None"}): self._fig = _matplotlib.pyplot.figure("Browser") self._fig.clear() #_matplotlib.pyplot.show() self._fig.set_facecolor("white") self._fig.subplots_adjust(left=0., bottom=0.1, right=1., top=0.95, wspace=0., hspace=0.05) self._axes = [self._fig.add_subplot(layout[0], layout[1], 1+i0*layout[1]+i1) for i0, i1 in _itertools.product(xrange(layout[0]), xrange(layout[1]))] ax_prev = self._fig.add_axes([0.1, 0.01, 0.3, 0.09]) ax_next = self._fig.add_axes([0.6, 0.01, 0.3, 0.09]) self._button_prev = _matplotlib.widgets.Button(ax_prev, "Previous") self._button_next = _matplotlib.widgets.Button(ax_next, "Next") self._button_prev.on_clicked(self._prev) self._button_next.on_clicked(self._next) self._page_text = self._fig.text(0.5, 0.05, "", va="center", ha="center") self._update_page_string() self._first_plot()
def context(style, after_reset=False): """Context manager for using style settings temporarily. Parameters ---------- style : str, dict, or list A style specification. Valid options are: +------+-------------------------------------------------------------+ | str | The name of a style or a path/URL to a style file. For a | | | list of available style names, see `style.available`. | +------+-------------------------------------------------------------+ | dict | Dictionary with valid key/value pairs for | | | `matplotlib.rcParams`. | +------+-------------------------------------------------------------+ | list | A list of style specifiers (str or dict) applied from first | | | to last in the list. | +------+-------------------------------------------------------------+ after_reset : bool If True, apply style after resetting settings to their defaults; otherwise, apply style on top of the current settings. """ with mpl.rc_context(): if after_reset: mpl.rcdefaults() use(style) yield
def test_view_limits(self): """ Test basic behavior of view limits. """ with matplotlib.rc_context({'axes.autolimit_mode': 'data'}): loc = mticker.MultipleLocator(base=3.147) assert_almost_equal(loc.view_limits(-5, 5), (-5, 5))
def _init_axis(self, fig, axis): """ Return an axis which may need to be initialized from a new figure. """ if not fig and self._create_fig: rc_params = self.fig_rcparams if self.fig_latex: rc_params['text.usetex'] = True with mpl.rc_context(rc=rc_params): fig = plt.figure() l, b, r, t = self.fig_bounds inches = self.fig_inches fig.subplots_adjust(left=l, bottom=b, right=r, top=t) fig.patch.set_alpha(self.fig_alpha) if isinstance(inches, (tuple, list)): inches = list(inches) if inches[0] is None: inches[0] = inches[1] elif inches[1] is None: inches[1] = inches[0] fig.set_size_inches(list(inches)) else: fig.set_size_inches([inches, inches]) axis = fig.add_subplot(111, projection=self.projection) axis.set_aspect('auto') return fig, axis
def plot_dA_dphi_vs_t(df, extras, figax=None, rcParams={}, filename=None): if figax is None: with mpl.rc_context(rcParams): fig, (ax1, ax2) = plt.subplots(nrows=2, sharex=True) else: fig, (ax1, ax2) = figax df_sorted = df.sort_values('phi_at_tp [rad]') control = df_sorted.loc['control'] f0 = control['f0 [Hz]'].median() td = control['phi_at_tp [rad]']/(2*np.pi*f0) * 1e6 ax1.plot(td, control['dA [nm]'], 'b.') ax1.plot(td, offset_cos(control['phi_at_tp [rad]'], *extras['popt_A'])) ax2.plot(td, control['dphi_tp_end [cyc]']*1e3, 'b.') ax2.plot(td, offset_cos(control['phi_at_tp [rad]'], *extras['popt_phi'])*1e3) ax1.grid() ax2.grid() ax1.set_xlabel(r'$\tau_\mathrm{d} \; [\mu\mathrm{s}]$') ax1.set_ylabel(r'$\Delta A \; [\mathrm{nm}]$') ax2.set_ylabel(r'$\Delta \phi \; [\mathrm{mcyc.}]$') if filename is not None: fig.savefig(filename, bbox_inches='tight') return fig, (ax1, ax2)
def test_embed_limit(method_name, caplog): with mpl.rc_context({"animation.embed_limit": 1e-6}): # ~1 byte. getattr(make_animation(frames=1), method_name)() assert len(caplog.records) == 1 record, = caplog.records assert (record.name == "matplotlib.animation" and record.levelname == "WARNING")
def test_plot(self, instance): with rc_context(rc={'text.usetex': False}): plot = instance.plot(figsize=(6.4, 3.8)) assert isinstance(plot, SegmentPlot) assert isinstance(plot.gca(), SegmentAxes) with tempfile.NamedTemporaryFile(suffix='.png') as f: plot.save(f.name)
def test_colorbar_closed_patch(): fig = plt.figure(figsize=(8, 6)) ax1 = fig.add_axes([0.05, 0.85, 0.9, 0.1]) ax2 = fig.add_axes([0.1, 0.65, 0.75, 0.1]) ax3 = fig.add_axes([0.05, 0.45, 0.9, 0.1]) ax4 = fig.add_axes([0.05, 0.25, 0.9, 0.1]) ax5 = fig.add_axes([0.05, 0.05, 0.9, 0.1]) cmap = cm.get_cmap("RdBu", lut=5) im = ax1.pcolormesh(np.linspace(0, 10, 16).reshape((4, 4)), cmap=cmap) # The use of a "values" kwarg here is unusual. It works only # because it is matched to the data range in the image and to # the number of colors in the LUT. values = np.linspace(0, 10, 5) cbar_kw = dict(cmap=cmap, orientation='horizontal', values=values, ticks=[]) # The wide line is to show that the closed path is being handled # correctly. See PR #4186. with rc_context({'axes.linewidth': 16}): plt.colorbar(im, cax=ax2, extend='both', extendfrac=0.5, **cbar_kw) plt.colorbar(im, cax=ax3, extend='both', **cbar_kw) plt.colorbar(im, cax=ax4, extend='both', extendrect=True, **cbar_kw) plt.colorbar(im, cax=ax5, extend='neither', **cbar_kw)
def plot_weight_comparisons(gd_file, mal_file, malicious_behaviour="Selfish", s="bella_static", excluded=None, show_title=True, figsize=None, labels=None, prefix="img/", extension="pdf"): if labels is None: labels = ["Fair", "Selfish"] if excluded is None: excluded = [] mtfm_args = ('n0', 'n1', ['n2', 'n3'], ['n4', 'n5']) with mpl.rc_context(rc={'text.usetex': 'True'}): gd_trust, mal_trust = per_scenario_gd_mal_trusts(gd_file, mal_file) gd_tp, mal_tp = per_scenario_gd_mal_trust_perspective(gd_trust, mal_trust, s=s) gd_mtfm = Trust.generate_mtfm(gd_tp, *mtfm_args).sum(axis=1) mal_mtfm = Trust.generate_mtfm(mal_tp, *mtfm_args).sum(axis=1) plot_comparison(gd_mtfm, mal_mtfm, s=s, show_title=show_title, keyword=malicious_behaviour, figsize=figsize, labels=labels, prefix=prefix, extension=extension, show_grid=False) for i, mi in enumerate(trust_metrics): if mi not in excluded: gd_tp, mal_tp = per_scenario_gd_mal_trust_perspective(gd_trust, mal_trust, s=s, weight_vector=weight_for_metric(mi, 3)) gd_mtfm = Trust.generate_mtfm(gd_tp, *mtfm_args).sum(axis=1) mal_mtfm = Trust.generate_mtfm(mal_tp, *mtfm_args).sum(axis=1) plot_comparison(gd_mtfm, mal_mtfm, s, metric=mi, show_title=show_title, prefix=prefix, keyword=malicious_behaviour, figsize=figsize, labels=labels, extension=extension, show_grid=False)
def __init__(self, layout, axis=None, create_axes=True, ranges=None, layout_num=1, keys=None, **params): if not isinstance(layout, GridSpace): raise Exception("GridPlot only accepts GridSpace.") super(GridPlot, self).__init__(layout, layout_num=layout_num, ranges=ranges, keys=keys, **params) # Compute ranges layoutwise grid_kwargs = {} if axis is not None: bbox = axis.get_position() l, b, w, h = bbox.x0, bbox.y0, bbox.width, bbox.height grid_kwargs = {'left': l, 'right': l+w, 'bottom': b, 'top': b+h} self.position = (l, b, w, h) self.cols, self.rows = layout.shape self.fig_inches = self._get_size() self._layoutspec = gridspec.GridSpec(self.rows, self.cols, **grid_kwargs) with mpl.rc_context(rc=self.fig_rcparams): self.subplots, self.subaxes, self.layout = self._create_subplots(layout, axis, ranges, create_axes) if self.top_level: self.comm = self.init_comm() self.traverse(lambda x: setattr(x, 'comm', self.comm)) self.traverse(lambda x: attach_streams(self, x.hmap, 2), [GenericElementPlot])
def test_font_priority(): with rc_context(rc={ 'font.sans-serif': ['cmmi10', 'Bitstream Vera Sans']}): font = findfont( FontProperties(family=["sans-serif"])) assert_equal(os.path.basename(font), 'cmmi10.ttf')
def test_colorbar_get_ticks(): with rc_context({'_internal.classic_mode': False}): fig, ax = plt.subplots() np.random.seed(19680801) pc = ax.pcolormesh(np.random.rand(30, 30)) cb = fig.colorbar(pc) np.testing.assert_allclose(cb.get_ticks(), [0.2, 0.4, 0.6, 0.8])
def test_plot(self, array): with rc_context(rc={'text.usetex': False}): plot = array.plot() line = plot.gca().lines[0] utils.assert_array_equal(line.get_xdata(), array.xindex.value) utils.assert_array_equal(line.get_ydata(), array.value) plot.save(BytesIO(), format='png') plot.close()
def test_patheffects(): with matplotlib.rc_context(): matplotlib.rcParams['path.effects'] = [ patheffects.withStroke(linewidth=4, foreground='w')] fig, ax = plt.subplots() ax.plot([1, 2, 3]) with io.BytesIO() as ps: fig.savefig(ps, format='ps')
def test_jpeg_alpha(): plt.figure(figsize=(1, 1), dpi=300) # Create an image that is all black, with a gradient from 0-1 in # the alpha channel from left to right. im = np.zeros((300, 300, 4), dtype=float) im[..., 3] = np.linspace(0.0, 1.0, 300) plt.figimage(im) buff = io.BytesIO() with rc_context({'savefig.facecolor': 'red'}): plt.savefig(buff, transparent=True, format='jpg', dpi=300) buff.seek(0) image = Image.open(buff) # If this fails, there will be only one color (all black). If this # is working, we should have all 256 shades of grey represented. num_colors = len(image.getcolors(256)) assert 175 <= num_colors <= 185 # The fully transparent part should be red. corner_pixel = image.getpixel((0, 0)) assert corner_pixel == (254, 0, 0)
def make(self): "Constructs the plot using the methods. This is the 'main' for ggplot" plt.close() with mpl.rc_context(): self.apply_theme() if self.facets: self.fig, self.subplots = self.make_facets() else: subplot_kw = {} if self.coords == "polar": subplot_kw = {"polar": True} self.fig, self.subplots = plt.subplots(subplot_kw=subplot_kw) self.apply_scales() legend, groups = self._construct_plot_data() self._aes.legend = legend for _, group in groups: for ax, facetgroup in self.get_facet_groups(group): for layer in self.layers: kwargs = self._prep_layer_for_plotting( layer, facetgroup) if kwargs == False: continue layer.plot(ax, facetgroup, self._aes, **kwargs) self.apply_limits() self.add_labels() self.apply_axis_scales() self.apply_axis_labels() self.apply_coords() self.add_legend(legend) if self.theme: for ax in self._iterate_subplots(): self.theme.apply_final_touches(ax)
def plot_roc(self): """ Plot receiver operating charactistic curve for this subject's classifier. """ fpr, tpr, _ = roc_curve(self.res['y'], self.res['probs']) with plt.style.context('fivethirtyeight'): with mpl.rc_context({ 'ytick.labelsize': 16, 'xtick.labelsize': 16 }): plt.plot(fpr, tpr, lw=4, label='ROC curve (AUC = %0.2f)' % self.res['auc']) plt.plot([0, 1], [0, 1], color='k', lw=2, linestyle='--', label='_nolegend_') plt.xlim([0.0, 1.0]) plt.ylim([0.0, 1.05]) plt.xlabel('False Positive Rate', fontsize=24) plt.ylabel('True Positive Rate', fontsize=24) plt.legend(loc="lower right") if 'p_val' not in self.res: title = 'ROC (AUC: {0:.3f})'.format(self.res['auc']) else: p = self.res['p_val'] if p == 0: p_str = '< {0:.2f}'.format(1 / self.num_iters) else: p_str = '= {0:.3f}'.format(p) title = 'ROC (AUC: {0:.3f}, p{1})'.format( self.res['auc'], p_str) plt.title(title) plt.gcf().set_size_inches(12, 9)
def _draw(self, return_ggplot=False): # Prevent against any modifications to the users # ggplot object. Do the copy here as we may/may not # assign a default theme self = deepcopy(self) self._build() # If no theme we use the default self.theme = self.theme or theme_get() try: with mpl.rc_context(): # setup & rcparams theming self.theme.apply_rcparams() figure, axs = self._create_figure() self._setup_parameters() self._resize_panels() # Drawing self._draw_layers() self._draw_labels() self._draw_breaks_and_labels() self._draw_legend() self._draw_title() self._draw_watermarks() # Artist object theming self._apply_theme() # !! except Exception as err: if self.figure is not None: plt.close(self.figure) raise err if return_ggplot: output = self.figure, self else: output = self.figure return output
def main() -> None: with mpl.rc_context(rc=DEFAULT_RC): fig, axes = plt.subplots(ncols=3, nrows=2, dpi=300, sharey=False) idx = 0 for dataset in DATASET_NAMES: datafile = DATAFILE_LIST[dataset] num_classes = NUM_CLASSES_DICT[dataset] categories, observations, confidences, idx2category, category2idx, labels = prepare_data(datafile, False) # accuracy models accuracy_model = BetaBernoulli(k=num_classes, prior=None) accuracy_model.update_batch(categories, observations) # ece models for each class ece_model = ClasswiseEce(num_classes, num_bins=10, pseudocount=2) ece_model.update_batch(categories, observations, confidences) # draw samples from posterior of classwise accuracy accuracy_samples = accuracy_model.sample(num_samples) # (num_categories, num_samples) ece_samples = ece_model.sample(num_samples) # (num_categories, num_samples) plot_kwargs = {} axes[idx // 3, idx % 3] = plot_scatter(axes[idx // 3, idx % 3], accuracy_samples, ece_samples, limit=TOPK_DICT[dataset], plot_kwargs=plot_kwargs) axes[idx // 3, idx % 3].set_title(DATASET_NAMES[dataset]) idx += 1 axes[0, 0].set_ylabel('ECE') axes[1, 0].set_ylabel('ECE') fig.set_size_inches(TEXT_WIDTH, 4.0) fig.subplots_adjust(bottom=0.05, wspace=0.2) fig.delaxes(axes.flatten()[5]) figname = FIGURE_DIR + 'scatter.pdf' fig.tight_layout() fig.savefig(figname, bbox_inches='tight', pad_inches=0)
def update_depth_limits(self): with rc_context(self.rc_context): if self.lib.has_ssp(): if len(self.lib.cur.proc.depth[self.vi]) > 0: max_proc_depth = self.lib.cur.proc.depth[self.vi].max() mean_sis_depth = 0 if self.lib.use_sis(): if self.lib.listeners.sis.xyz: if self.lib.listeners.sis.xyz_mean_depth: mean_sis_depth = self.lib.listeners.sis.xyz_mean_depth max_proc_sis_depth = max(max_proc_depth, mean_sis_depth) max_depth = max(30. + max_proc_sis_depth, 1.1 * max_proc_sis_depth) min_depth = -0.05 * max_proc_sis_depth if min_depth > 0: min_depth = -5 self.speed_ax.set_ylim(bottom=max_depth, top=min_depth) self.c.draw()
def __init__(self, layout, axis=None, create_axes=True, ranges=None, layout_num=1, keys=None, **params): if not isinstance(layout, GridSpace): raise Exception("GridPlot only accepts GridSpace.") super(GridPlot, self).__init__(layout, layout_num=layout_num, ranges=ranges, keys=keys, **params) # Compute ranges layoutwise grid_kwargs = {} if axis is not None: bbox = axis.get_position() l, b, w, h = bbox.x0, bbox.y0, bbox.width, bbox.height grid_kwargs = {'left': l, 'right': l+w, 'bottom': b, 'top': b+h} self.position = (l, b, w, h) self.cols, self.rows = layout.shape self.fig_inches = self._get_size() self._layoutspec = gridspec.GridSpec(self.rows, self.cols, **grid_kwargs) with mpl.rc_context(rc=self.fig_rcparams): self.subplots, self.subaxes, self.layout = self._create_subplots(layout, axis, ranges, create_axes) if self.top_level: self.traverse(lambda x: attach_streams(self, x.hmap, 2), [GenericElementPlot])
def test_rcparams(self): # Test custom rcParams with rc_context({ 'axes.labelcolor': 'purple', 'axes.labelsize': 14, 'axes.labelweight': 'bold', 'axes.linewidth': 3, 'axes.facecolor': '0.5', 'axes.edgecolor': 'green', 'xtick.color': 'red', 'xtick.labelsize': 8, 'xtick.direction': 'in', 'xtick.minor.visible': True, 'xtick.minor.size': 5, 'xtick.major.size': 20, 'xtick.major.width': 3, 'xtick.major.pad': 10, 'grid.color': 'blue', 'grid.linestyle': ':', 'grid.linewidth': 1, 'grid.alpha': 0.5 }): fig = plt.figure(figsize=(6, 6)) ax = WCSAxes(fig, [0.15, 0.1, 0.7, 0.7], wcs=None) fig.add_axes(ax) ax.set_xlim(-0.5, 2) ax.set_ylim(-0.5, 2) ax.grid() ax.set_xlabel('X label') ax.set_ylabel('Y label') ax.coords[0].set_ticklabel(exclude_overlapping=True) ax.coords[1].set_ticklabel(exclude_overlapping=True) return fig
def _draw_using_figure(self, figure, axs): """ Draw onto already created figure and axes This is can be used to draw animation frames, or inset plots. It is intended to be used after the key plot has been drawn. Parameters ---------- figure : matplotlib.figure.Figure Matplotlib figure axs : array_like Array of Axes onto which to draw the plots """ self = deepcopy(self) self._build() self.theme = self.theme or theme_get() self.figure = figure self.axs = axs try: with mpl.rc_context(): self.theme.apply_rcparams() self._setup_parameters() self._draw_layers() self._draw_facet_labels() self._draw_legend() self._apply_theme() except Exception as err: if self.figure is not None: plt.close(self.figure) raise err return self
def test_colorbar_autotickslog(): # Test new autotick modes... with rc_context({'_internal.classic_mode': False}): fig, ax = plt.subplots(2, 1) x = np.arange(-3.0, 4.001) y = np.arange(-4.0, 3.001) X, Y = np.meshgrid(x, y) Z = X * Y pcm = ax[0].pcolormesh(X, Y, 10**Z, norm=LogNorm()) cbar = fig.colorbar(pcm, ax=ax[0], extend='both', orientation='vertical') pcm = ax[1].pcolormesh(X, Y, 10**Z, norm=LogNorm()) cbar2 = fig.colorbar(pcm, ax=ax[1], extend='both', orientation='vertical', shrink=0.4) np.testing.assert_almost_equal(cbar.ax.yaxis.get_ticklocs(), 10**np.arange(-12, 12.2, 4.)) np.testing.assert_almost_equal(cbar2.ax.yaxis.get_ticklocs(), 10**np.arange(-12, 13., 12.))
def save(self, path, format: Optional[str] = None, dpi: Optional[float] = 150): """Saves the figure to a file. Parameters ---------- path: ``tuple`` of ``float``, optional Path in which to store the file. format: ``str``, optional File format, e.g. ``'png'``, ``'pdf'``, ``'svg'``. If not provided, the output format is inferred from the extension of ``path``. dpi: ``float``, optional Resolution in dots per inch. If not provided, defaults to ``150``. """ with mpl.rc_context(fname=self.fname, rc=self.rc): self.fig.tight_layout() self.fig.savefig(path, dpi=dpi, bbox_inches="tight")
def plot_values(self, ids, model, ymax, ymin, dpi=300, sub=None, subagg=None, cells=None, pairwise=False, colors=None, prefix=None, w=None, filter=None, legend=False): """Plot values in cluster Parameters ---------- ids : sequence | dict | scalar <= 1 IDs of the clusters that should be plotted. For ANOVA results, this should be an ``{effect_name: id_list}`` dict. Instead of a list of IDs a scalar can be provided to plot all clusters with p-values smaller than this. model : str Model defining cells which to plot separately. ymax : scalar Top of the y-axis. ymin : scalar Bottom of the y axis. dpi : int Figure DPI. sub : str Only use a subset of the data. subagg : str Index in ds: within index, collapse across other predictors. cells : sequence of cells in model Modify visible cells and their order. Only applies to the barplot. Does not affect filename. pairwise : bool Add pairwise tests to barplots. colors : dict Substitute colors (default are the colors provided at initialization). prefix : str Prefix to use for the image files (optional, can be used to distinguish different groups of images sharing the same color-bars). w : scalar UTS-stat plot width (default is ``2 * h``). filter : Filter Filter signal for display purposes (optional). legend : bool Plot a color legend. """ if w is None: w = self.h * 2 ds, model, modelname = self._get_data(model, sub, subagg) ids = self._ids(ids) if colors is None: colors = self.colors src = ds['srcm'] n_cells = len(ds.eval(model).cells) w_bar = (n_cells * 2 + 4) * (self.h / 12) with mpl.rc_context(self.rc): for cid in ids: name = cname(cid) if prefix: name = prefix + ' ' + name cluster = self._get_cluster(cid) y_mean = src.mean(cluster != 0) y_tc = src.mean(cluster.any('time')) # barplot p = plot.Barplot(y_mean, model, 'subject', None, cells, pairwise, ds=ds, trend=False, corr=None, title=None, frame=False, yaxis=False, ylabel=False, colors=colors, bottom=ymin, top=ymax, w=w_bar, h=self.h, xlabel=None, xticks=None, tight=False, test_markers=False, show=False) p.save(self._dst.vec % ' '.join((name, modelname, 'barplot')), dpi=dpi, transparent=True) p.close() # time-course if filter is not None: y_tc = filter.filtfilt(y_tc) p = plot.UTSStat(y_tc, model, match='subject', ds=ds, error='sem', colors=colors, title=None, axtitle=None, frame=False, bottom=ymin, top=ymax, legend=None, ylabel=None, xlabel=None, w=w, h=self.h, tight=False, show=False) dt = y_tc.time.tstep / 2. mark_start = cluster.info['tstart'] - dt mark_stop = cluster.info['tstop'] - dt p.add_vspan(mark_start, mark_stop, color='k', alpha=0.1, zorder=-2) p.save(self._dst.vec % ' '.join( (name, modelname, 'timecourse')), dpi=dpi, transparent=True) p.close() # legend (only once) if legend: p.save_legend(self._dst.vec % (modelname + ' legend'), transparent=True) legend = False
def plot_clusters_spatial(self, ids, views, w=600, h=480, prefix=''): """Plot spatial extent of the clusters Parameters ---------- ids : sequence | dict | scalar <= 1 IDs of the clusters that should be plotted. For ANOVA results, this should be an ``{effect_name: id_list}`` dict. Instead of a list of IDs a scalar can be provided to plot all clusters with p-values smaller than this. views : str | list of str | dict Can a str or list of str to use the same views for all clusters. A dict can have as keys labels or cluster IDs. w, h : int Size in pixels. The default (600 x 480) corresponds to 2 x 1.6 in at 300 dpi. prefix : str Prefix to use for the image files (optional, can be used to distinguish different groups of images sharing the same color-bars). Notes ----- The horizontal colorbar is 1.5 in wide, the vertical colorbar is 1.6 in high. """ ids = self._ids(ids) clusters = self._get_clusters(ids) clusters_spatial = [c.sum('time') for c in clusters] if isinstance(views, str): views = (views, ) # vmax vmin = min(c.min() for c in clusters_spatial) vmax = max(c.max() for c in clusters_spatial) abs_vmax = max(vmax, abs(vmin)) # anatomical extent brain_colorbar_done = False for cid, cluster in zip(ids, clusters_spatial): name = cname(cid) if prefix: name = prefix + ' ' + name for hemi in ('lh', 'rh'): if not cluster.sub(source=hemi).any(): continue brain = plot.brain.cluster(cluster, abs_vmax, views='lat', background=(1, 1, 1), colorbar=False, parallel=True, hemi=hemi, w=w, h=h) for view in views: brain.show_view(view) brain.save_image( self._dst_pix % ' '.join((name, hemi, view)), 'rgba', True) if not brain_colorbar_done: with mpl.rc_context(self.rc): label = "Sum of %s-values" % cluster.info['meas'] clipmin = 0 if vmin == 0 else None clipmax = 0 if vmax == 0 else None if prefix: cbar_name = '%s cbar %%s' % prefix else: cbar_name = 'cbar %s' h_cmap = 0.7 + POINT * mpl.rcParams['font.size'] p = brain.plot_colorbar(label, clipmin=clipmin, clipmax=clipmax, width=0.1, h=h_cmap, w=1.5, show=False) p.save(self._dst.vec % cbar_name % 'h', transparent=True) p.close() w_cmap = 0.8 + 0.1 * abs(floor(log10(vmax))) p = brain.plot_colorbar(label, clipmin=clipmin, clipmax=clipmax, width=0.1, h=1.6, w=w_cmap, orientation='vertical', show=False) p.save(self._dst.vec % cbar_name % 'v', transparent=True) p.close() brain_colorbar_done = True brain.close()
def plot_classification_categorical(X, target_col, types=None, kind='auto', hue_order=None, **kwargs): """Plots for categorical features in classification. Creates plots of categorical variable distributions for each target class. Relevant features are identified via mutual information. For high cardinality categorical variables (variables with many categories) only the most frequent categories are shown. Parameters ---------- X : dataframe Input data including features and target target_col : str or int Identifier of the target column in X types : dataframe of types, optional. Output of detect_types on X. Can be used to avoid recomputing the types. kind : string, default 'auto' Kind of plot to show. Options are 'count', 'proportion', 'mosaic' and 'auto'. Count shows raw class counts within categories (can be hard to read with imbalanced classes) Proportion shows class proportions within categories (can be misleading with imbalanced categories) Mosaic shows both aspects, but can be a bit busy. Auto uses mosaic plots for binary classification and counts otherwise. """ types = _check_X_target_col(X, target_col, types, task="classification") if kind == "auto": if X[target_col].nunique() > 5: kind = 'count' else: kind = 'mosaic' features = X.loc[:, types.categorical] if target_col in features.columns: features = features.drop(target_col, axis=1) if features.shape[1] == 0: return features = features.astype('category') show_top = _get_n_top(features, "categorical") # can't use OrdinalEncoder because we might have mix of int and string ordinal_encoded = features.apply(lambda x: x.cat.codes) target = X[target_col] f = mutual_info_classif(ordinal_encoded, target, discrete_features=np.ones(X.shape[1], dtype=bool)) top_k = np.argsort(f)[-show_top:][::-1] # large number of categories -> taller plot row_height = 3 if features.nunique().max() <= 5 else 5 fig, axes = _make_subplots(n_plots=show_top, row_height=row_height) plt.suptitle("Categorical Features vs Target", y=1.02) for i, (col_ind, ax) in enumerate(zip(top_k, axes.ravel())): col = features.columns[col_ind] if kind == 'proportion': X_new = _prune_category_make_X(X, col, target_col) df = (X_new.groupby(col)[target_col].value_counts( normalize=True).unstack().sort_values(by=target[0]) ) # hacky way to get a class name df.plot(kind='barh', stacked='True', ax=ax, legend=i == 0) ax.set_title(col) ax.set_ylabel(None) elif kind == 'mosaic': # how many categories make up at least 1% of data: n_cats = (X[col].value_counts() / len(X) > 0.01).sum() n_cats = np.minimum(n_cats, 20) X_new = _prune_category_make_X(X, col, target_col, max_categories=n_cats) mosaic_plot(X_new, col, target_col, ax=ax) ax.set_title(col) elif kind == 'count': X_new = _prune_category_make_X(X, col, target_col) # absolute counts # FIXME show f value # FIXME shorten titles? props = {} if X[target_col].nunique() > 15: props['font.size'] = 6 with mpl.rc_context(props): sns.countplot(y=col, data=X_new, ax=ax, hue=target_col, hue_order=hue_order) if i > 0: ax.legend(()) else: raise ValueError("Unknown plot kind {}".format(kind)) _short_tick_names(ax) for j in range(i + 1, axes.size): # turn off axis if we didn't fill last row axes.ravel()[j].set_axis_off()
def map_profiles(self, pks=None, output_folder=None, save_fig=False): """plot all the ssp in the database""" with rc_context(self.rc_context): if not save_fig: plt.ion() rows = self.db.list_profiles() if rows is None: raise RuntimeError( "Unable to retrieve ssp view rows > Empty database?") if len(rows) == 0: raise RuntimeError( "Unable to retrieve ssp view rows > Empty database?") # prepare the data ssp_x = list() ssp_y = list() ssp_label = list() for row in rows: if pks is not None: # only if a pk-based filter was passed if row[0] in pks: ssp_x.append(row[2].x) ssp_y.append(row[2].y) ssp_label.append(row[0]) else: ssp_x.append(row[2].x) ssp_y.append(row[2].y) ssp_label.append(row[0]) # make the world map plt.close("Profiles Map") fig = plt.figure("Profiles Map") # fig.patch.set_facecolor('#1464F4') ax = plt.subplot(111, aspect='equal') plt.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=0, hspace=0) # plt.title("SSP Map (%s profiles)" % len(view_rows)) plt.ioff() if rows: wm = self._world_draw_polygons() else: wm = self._world_draw_map() x, y = wm(ssp_x, ssp_y) wm.scatter(x, y, marker='o', s=16, color='r') wm.scatter(x, y, marker='.', s=1, color='k') if pks is not None: delta = 5.0 y_min = min(y) if (y_min - delta) < -90.0: y_min = -90.0 else: y_min -= delta y_max = max(y) if (y_max + delta) > 90.0: y_max = 90.0 else: y_max += delta x_min = min(x) if (x_min - delta) < -180.0: x_min = -180.0 else: x_min = x_min - delta x_max = max(x) if (x_max + delta) > 180.0: x_max = 180.0 else: x_max += delta # logger.debug("%s %s, %s %s" % (y_min, y_max, x_min, x_max)) ax.set_ylim(y_min, y_max) ax.set_xlim(x_min, x_max) if save_fig and (output_folder is not None): plt.savefig(os.path.join(self.plots_folder(output_folder), 'ssp_map.png'), bbox_inches='tight') # else: # plt.show() return True
def test_basic(self, xmax, decimals, symbol, x, display_range, expected): formatter = mticker.PercentFormatter(xmax, decimals, symbol) with matplotlib.rc_context(rc={'text.usetex': False}): assert formatter.format_pct(x, display_range) == expected
def test_min_exponent(self, min_exponent, value, expected): with matplotlib.rc_context({'axes.formatter.min_exponent': min_exponent}): assert self.fmt(value) == expected
def test_auto_date_locator_intmult_tz(): def _create_auto_date_locator(date1, date2, tz): locator = mdates.AutoDateLocator(interval_multiples=True, tz=tz) locator.create_dummy_axis() locator.set_view_interval(mdates.date2num(date1), mdates.date2num(date2)) return locator results = ([ datetime.timedelta(weeks=52 * 200), [ '1980-01-01 00:00:00-08:00', '2000-01-01 00:00:00-08:00', '2020-01-01 00:00:00-08:00', '2040-01-01 00:00:00-08:00', '2060-01-01 00:00:00-08:00', '2080-01-01 00:00:00-08:00', '2100-01-01 00:00:00-08:00', '2120-01-01 00:00:00-08:00', '2140-01-01 00:00:00-08:00', '2160-01-01 00:00:00-08:00', '2180-01-01 00:00:00-08:00', '2200-01-01 00:00:00-08:00' ] ], [ datetime.timedelta(weeks=52), [ '1997-01-01 00:00:00-08:00', '1997-02-01 00:00:00-08:00', '1997-03-01 00:00:00-08:00', '1997-04-01 00:00:00-08:00', '1997-05-01 00:00:00-07:00', '1997-06-01 00:00:00-07:00', '1997-07-01 00:00:00-07:00', '1997-08-01 00:00:00-07:00', '1997-09-01 00:00:00-07:00', '1997-10-01 00:00:00-07:00', '1997-11-01 00:00:00-08:00', '1997-12-01 00:00:00-08:00' ] ], [ datetime.timedelta(days=141), [ '1997-01-01 00:00:00-08:00', '1997-01-15 00:00:00-08:00', '1997-02-01 00:00:00-08:00', '1997-02-15 00:00:00-08:00', '1997-03-01 00:00:00-08:00', '1997-03-15 00:00:00-08:00', '1997-04-01 00:00:00-08:00', '1997-04-15 00:00:00-07:00', '1997-05-01 00:00:00-07:00', '1997-05-15 00:00:00-07:00' ] ], [ datetime.timedelta(days=40), [ '1997-01-01 00:00:00-08:00', '1997-01-05 00:00:00-08:00', '1997-01-09 00:00:00-08:00', '1997-01-13 00:00:00-08:00', '1997-01-17 00:00:00-08:00', '1997-01-21 00:00:00-08:00', '1997-01-25 00:00:00-08:00', '1997-01-29 00:00:00-08:00', '1997-02-01 00:00:00-08:00', '1997-02-05 00:00:00-08:00', '1997-02-09 00:00:00-08:00' ] ], [ datetime.timedelta(hours=40), [ '1997-01-01 00:00:00-08:00', '1997-01-01 04:00:00-08:00', '1997-01-01 08:00:00-08:00', '1997-01-01 12:00:00-08:00', '1997-01-01 16:00:00-08:00', '1997-01-01 20:00:00-08:00', '1997-01-02 00:00:00-08:00', '1997-01-02 04:00:00-08:00', '1997-01-02 08:00:00-08:00', '1997-01-02 12:00:00-08:00', '1997-01-02 16:00:00-08:00' ] ], [ datetime.timedelta(minutes=20), [ '1997-01-01 00:00:00-08:00', '1997-01-01 00:05:00-08:00', '1997-01-01 00:10:00-08:00', '1997-01-01 00:15:00-08:00', '1997-01-01 00:20:00-08:00' ] ], [ datetime.timedelta(seconds=40), [ '1997-01-01 00:00:00-08:00', '1997-01-01 00:00:05-08:00', '1997-01-01 00:00:10-08:00', '1997-01-01 00:00:15-08:00', '1997-01-01 00:00:20-08:00', '1997-01-01 00:00:25-08:00', '1997-01-01 00:00:30-08:00', '1997-01-01 00:00:35-08:00', '1997-01-01 00:00:40-08:00' ] ]) tz = dateutil.tz.gettz('Canada/Pacific') d1 = datetime.datetime(1997, 1, 1, tzinfo=tz) for t_delta, expected in results: with rc_context({'_internal.classic_mode': False}): d2 = d1 + t_delta locator = _create_auto_date_locator(d1, d2, tz) st = list(map(str, mdates.num2date(locator(), tz=tz))) assert st == expected
def process_cluster_overlap_stats( cluster_overlap_stats, max_pvalues, plot_args, barcode_plot_png_by_maxpvalue, cluster_overlap_stats_out_fp, plotting_context, test_arg_dict=None, sample=None, cores=1, plots_only=False, additional_formats=None, ): if additional_formats is None: additional_formats = tuple() if not plots_only: if sample is not None and sample < cluster_overlap_stats.hits.shape[1]: random_sel = np.random.choice(cluster_overlap_stats.hits.shape[1], sample, replace=False) cluster_overlap_stats.hits = cluster_overlap_stats.hits.iloc[:, random_sel] # print("Calculate test per feature") final_test_args = dict(simulate_pval=True, replicate=int(1e4), workspace=1_000_000) if test_arg_dict is not None: final_test_args.update(test_arg_dict) cluster_overlap_stats.test_per_feature(method="hybrid", cores=cores, test_args=final_test_args) # print("Calculate test per cluster per feature") cluster_overlap_stats.test_per_cluster_per_feature() with open(cluster_overlap_stats_out_fp, "wb") as fout: pickle.dump(cluster_overlap_stats, fout) cluster_overlap_stats.hits.to_pickle( cluster_overlap_stats_out_fp[:-2] + "_hits.p") cluster_overlap_stats.hits.to_csv(cluster_overlap_stats_out_fp[:-2] + "_hits.tsv", sep="\t", index=False) cluster_overlap_stats.cluster_pvalues.to_csv( cluster_overlap_stats_out_fp[:-2] + "_element-pvalues.tsv", sep="\t", index=False, ) cluster_overlap_stats.log_odds_ratio.to_csv( cluster_overlap_stats_out_fp[:-2] + "_log-odds.tsv", sep="\t", index=False) cluster_overlap_stats: rsp.ClusterOverlapStats for max_pvalue in max_pvalues: # print("Create barcode figure", "max_pvalue", max_pvalue) cluster_overlap_stats_filtered = cluster_overlap_stats.filter( "cluster_pvalues", max_pvalue) if not cluster_overlap_stats_filtered.cluster_pvalues.empty: with mpl.rc_context(plotting_context): fig = rsp.barcode_heatmap( cluster_overlap_stats_filtered, **plot_args, ) out_png = barcode_plot_png_by_maxpvalue.format( max_pvalue=max_pvalue) fig.set_dpi(90) fig.savefig(out_png) if "pdf" in additional_formats: fig.savefig(out_png.replace(".png", ".pdf")) if "svg" in additional_formats: fig.savefig(out_png.replace(".png", ".svg")) plt.close() else: print( f"WARNING: not features left for pvalue {max_pvalue} threshold. No plot created" )
from __future__ import absolute_import, division, print_function import copy import matplotlib from matplotlib import pyplot as plt from matplotlib._pylab_helpers import Gcf import pytest try: # mock in python 3.3+ from unittest import mock except ImportError: import mock with matplotlib.rc_context(rc={'backend': 'Qt5Agg'}): qt_compat = pytest.importorskip('matplotlib.backends.qt_compat', minversion='5') from matplotlib.backends.backend_qt5 import ( MODIFIER_KEYS, SUPER, ALT, CTRL, SHIFT) # noqa QtCore = qt_compat.QtCore _, ControlModifier, ControlKey = MODIFIER_KEYS[CTRL] _, AltModifier, AltKey = MODIFIER_KEYS[ALT] _, SuperModifier, SuperKey = MODIFIER_KEYS[SUPER] _, ShiftModifier, ShiftKey = MODIFIER_KEYS[SHIFT] @pytest.mark.backend('Qt5Agg') def test_fig_close(): # save the state of Gcf.figs
def demo(ax, rcparams, title): ax.axis('off') ax.set_title(title) with mpl.rc_context(rc=rcparams): for j, sty in enumerate(sty_cycle): ax.plot(x, y + j, **sty)
def test_using_all_default_major_steps(self): with matplotlib.rc_context({'_internal.classic_mode': False}): majorsteps = [x[0] for x in self.majorstep_minordivisions] np.testing.assert_allclose(majorsteps, mticker.AutoLocator()._steps)
def test_use_offset(self, use_offset): with matplotlib.rc_context({'axes.formatter.useoffset': use_offset}): tmp_form = mticker.ScalarFormatter() assert use_offset == tmp_form.get_useOffset()
def test_get_color_cycle(cycler, result): with mpl.rc_context(rc={"axes.prop_cycle": cycler}): assert get_color_cycle() == result
def test_basic(self, base, value, expected): formatter = mticker.LogFormatterSciNotation(base=base) formatter.sublabel = {1, 2, 5, 1.2} with matplotlib.rc_context({'text.usetex': False}): assert formatter(value) == expected
def test_use_offset(): for use_offset in [True, False]: with matplotlib.rc_context({'axes.formatter.useoffset': use_offset}): tmp_form = mticker.ScalarFormatter() assert use_offset == tmp_form.get_useOffset()
def test_latex(self, is_latex, usetex, expected): fmt = mticker.PercentFormatter(symbol='\\{t}%', is_latex=is_latex) with matplotlib.rc_context(rc={'text.usetex': usetex}): assert fmt.format_pct(50, 100) == expected
import yt from matplotlib.animation import FuncAnimation from matplotlib import rc_context ts = yt.load('GasSloshingLowRes/sloshing_low_res_hdf5_plt_cnt_*') plot = yt.SlicePlot(ts[0], 'z', 'density') plot.set_zlim('density', 8e-29, 3e-26) fig = plot.plots['density'].figure # animate must accept an integer frame number. We use the frame number # to identify which dataset in the time series we want to load def animate(i): ds = ts[i] plot._switch_ds(ds) animation = FuncAnimation(fig, animate, frames=len(ts)) # Override matplotlib's defaults to get a nicer looking font with rc_context({'mathtext.fontset': 'stix'}): animation.save('animation.mp4')
def test_plot(self, instance): with rc_context(rc={'text.usetex': False}): plot = instance.plot(figsize=(6.4, 3.8)) assert isinstance(plot.gca(), SegmentAxes) plot.save(BytesIO(), format='png') plot.close()
def process(self, outputfile=None, close=True): with rc_context(rc=self.rcParams): return self.draw()