Python matplotlib.get_backend函数代码示例

def _init_matplotlib():
    import matplotlib as mpl
    import utool
    backend = mpl.get_backend()
    if not sys.platform.startswith('win32') and not sys.platform.startswith('darwin') and os.environ.get('DISPLAY', None) is None:
        # Write to files if we cannot display
        TARGET_BACKEND = 'PDF'
    else:
        TARGET_BACKEND = 'Qt4Agg'
    if utool.in_main_process():
        if not utool.QUIET and utool.VERBOSE:
            print('--- INIT MPL---')
            print('[main] current backend is: %r' % backend)
            print('[main] mpl.use(%r)' % TARGET_BACKEND)
        if backend != TARGET_BACKEND:
            mpl.use(TARGET_BACKEND, warn=True, force=True)
            backend = mpl.get_backend()
            if not utool.QUIET and utool.VERBOSE:
                print('[main] current backend is: %r' % backend)
        if utool.get_flag('--notoolbar'):
            toolbar = 'None'
        else:
            toolbar = 'toolbar2'
        mpl.rcParams['toolbar'] = toolbar
        mpl.rc('text', usetex=False)
        mpl_keypress_shortcuts = [key for key in mpl.rcParams.keys() if key.find('keymap') == 0]
        for key in mpl_keypress_shortcuts:
            mpl.rcParams[key] = ''

def Show():
    """
    Show all figures and start the event loop if necessary
    """
    managers = GlobalFigureManager.get_all_fig_managers()
    if not managers:
        return

    for manager in managers:
        manager.show()

    # Hack: determine at runtime whether we are
    # inside ipython in pylab mode.
    from matplotlib import pyplot

    try:
        ipython_pylab = not pyplot.show._needmain
        # IPython versions >= 0.10 tack the _needmain
        # attribute onto pyplot.show, and always set
        # it to False, when in %pylab mode.
        ipython_pylab = ipython_pylab and mpl.get_backend() != 'WebAgg'
        # TODO: The above is a hack to get the WebAgg backend
        # working with ipython's `%pylab` mode until proper
        # integration is implemented.
    except AttributeError:
        ipython_pylab = False

    # Leave the following as a separate step in case we
    # want to control this behavior with an rcParam.
    if ipython_pylab:
        return

    if not mpl.is_interactive() or mpl.get_backend() == 'WebAgg':
        QAppThreadCall(mainloop)()

def _setup():
    # The baseline images are created in this locale, so we should use
    # it during all of the tests.
    import locale
    import warnings
    from matplotlib.backends import backend_agg, backend_pdf, backend_svg

    try:
        locale.setlocale(locale.LC_ALL, str('en_US.UTF-8'))
    except locale.Error:
        try:
            locale.setlocale(locale.LC_ALL, str('English_United States.1252'))
        except locale.Error:
            warnings.warn(
                "Could not set locale to English/United States. "
                "Some date-related tests may fail")

    mpl.use('Agg', warn=False)  # use Agg backend for these tests
    if mpl.get_backend().lower() != "agg":
        raise Exception(("Using a wrong matplotlib backend ({0}), which will not produce proper "
                        "images").format(mpl.get_backend()))

    # These settings *must* be hardcoded for running the comparison
    # tests
    mpl.rcdefaults()  # Start with all defaults
    mpl.rcParams['text.hinting'] = True
    mpl.rcParams['text.antialiased'] = True
    #mpl.rcParams['text.hinting_factor'] = 8

    # Clear the font caches.  Otherwise, the hinting mode can travel
    # from one test to another.
    backend_agg.RendererAgg._fontd.clear()
    backend_pdf.RendererPdf.truetype_font_cache.clear()
    backend_svg.RendererSVG.fontd.clear()

def save_figure_helper(fpath):
    if matplotlib.get_backend() == 'pdf':
        final_path = fpath + '.pdf'
        pylab.savefig(final_path)
        pylab.close()
        print('Written: %s'%final_path)
        print('Converting to eps...')
        os.system('pdftops -eps ' + final_path)
        os.rename(fpath+'.eps', fpath+'_.eps') #missing bounding box
        os.system('eps2eps ' + fpath+'_.eps' + '  ' + fpath+'.eps')
        os.remove(fpath+'_.eps')
    elif matplotlib.get_backend() == 'ps':
        final_path = fpath + '.eps'
        pylab.savefig(final_path)
        pylab.close()
        print('Written: %s'%final_path)
        print('Converting to pdf...')
        os.system('epstopdf ' + final_path)
    else:
        print('Trying to save to PDF.  Backend: %s'%matplotlib.get_backend())
        final_path = fpath + '.pdf'
        pylab.savefig(final_path)
        pylab.close()
        print('Written: %s'%final_path)
    subprocess.call(['xdg-open', final_path])

 def do_ui_pause(self, prompt=None):
     """Make a UI pause without regard to the current pause state."""
     if prompt is None:
         prompt = "Paused. Press ENTER to continue..."
     if not plt.get_fignums():  # empty list: no figures are open
         input(prompt)
     else:  # a figure is open
         if matplotlib.get_backend().upper().startswith("GTK"):
             title_before = plt.gcf().canvas.get_toplevel().get_title()
         elif matplotlib.get_backend().upper().startswith("TK"):
             title_before = plt.gcf().canvas.get_tk_widget().winfo_toplevel().wm_title()
         elif matplotlib.get_backend().upper().startswith("WX"):
             title_before = plt.gcf().canvas.GetTopLevelParent().GetTitle()
         elif matplotlib.get_backend().upper().startswith("QT"):
             title_before = str(plt.gcf().canvas.topLevelWidget().windowTitle())
         else:
             title_before = "Figure %d" % plt.gcf().number
         while True:  # wait until a key is pressed. Blink the title meanwhile.
             plt.gcf().canvas.set_window_title(prompt)
             result = plt.gcf().waitforbuttonpress(1)
             if result:  # waitforbuttonpress returns True for keypress, False for mouse click and None for timeout
                 break
             plt.gcf().canvas.set_window_title(title_before)
             result = plt.gcf().waitforbuttonpress(1)
             if result:  # waitforbuttonpress returns True for keypress, False for mouse click and None for timeout
                 break
         plt.gcf().canvas.set_window_title(title_before)

def ensure_mpl_backend(backend=None):
    """
    Tries to select the matplotlib backend.

    Raises EnvironmentError, if the desired backend is valid
    but could not be selected.
    If `backend` is None, either 'agg' or 'wxagg' is chosen,
    depending on whether a display is present (on Linux and Darwin).
    For other platforms, 'wxagg' is always the default.
    Returns the selected backend as given by matplotlib.get_backend().
    """
    if backend is None:
        import platform
        import os
        if (
            platform.system() in ('Linux', 'Darwin') and not
            'DISPLAY' in os.environ
            ):
            backend = 'agg'
        else:
            backend = 'wxagg'
    import matplotlib
    active_backend = matplotlib.get_backend()
    if active_backend.lower() != backend.lower():
        matplotlib.use(backend)
        active_backend = matplotlib.get_backend()
        if active_backend.lower() != backend.lower():
            raise EnvironmentError(
                "Could not select matplotlib backend '%s' ('%s' is active)!" \
                % (backend, active_backend)
                )
    return active_backend

    def __init__(self, work_dir=None, backend='TkAgg'):
        if work_dir != None and os.path.exists(work_dir):
            self.__WORK_DIR__ = work_dir
        else:
            self.__WORK_DIR__ = os.getcwd()
        try:
            import matplotlib
            if backend in self.__INTERACTIVE_BACKENDS__:
                matplotlib.use(backend, warn=False)
                self.__BACKEND__ = backend
                if not __SILENT_START__:
                    print(('Matplotlib backend set to: \"{}\"'.format(backend)))
            else:
                if backend in [None, 'None', 'none']:
                    print(('Matplotlib backend not set, using: \"{}\"'.format(matplotlib.get_backend())))
                    self.__BACKEND__ = matplotlib.get_backend()
                else:
                    matplotlib.use('TkAgg', warn=False)
                    self.__BACKEND__ = 'TkAgg'
                    print(('Matplotlib \"{}\" backend not set, defaulting to: \"{}\"'.format(backend, 'TkAgg')))

            #if self.__ENABLE_HTML5__:
                #matplotlib.use('module://mplh5canvas.backend_h5canvas') # HTML5
            #else:
                #matplotlib.use('TKagg', warn=False)
        except Exception as ex:
            print(ex)
            print("\nPySCeS defaults to matplotlib's TKagg backend if not specified in the user conficuration file, set \"matplotlib_backend = <backend>\" ")

        from matplotlib import pyplot
        from matplotlib import pylab
        ##  self.pyplot = pyplot
        self.pyplot = pylab
        if self.__MODE_INTERACTIVE__: self.pyplot.ion()
        self._setNewFigureGenerator(self.MAX_OPEN_WINDOWS)

def _setup():
    # The baseline images are created in this locale, so we should use
    # it during all of the tests.
    try:
        locale.setlocale(locale.LC_ALL, str('en_US.UTF-8'))
    except locale.Error:
        try:
            locale.setlocale(locale.LC_ALL, str('English_United States.1252'))
        except locale.Error:
            warnings.warn(
                "Could not set locale to English/United States. "
                "Some date-related tests may fail")

    plt.switch_backend('Agg')  # use Agg backend for these test
    if mpl.get_backend().lower() != "agg":
        msg = ("Using a wrong matplotlib backend ({0}), "
               "which will not produce proper images")
        raise Exception(msg.format(mpl.get_backend()))

    # These settings *must* be hardcoded for running the comparison
    # tests
    mpl.rcdefaults()  # Start with all defaults
    mpl.rcParams['text.hinting'] = True
    mpl.rcParams['text.antialiased'] = True
    mpl.rcParams['text.hinting_factor'] = 8

    # make sure we don't carry over bad plots from former tests
    msg = ("no of open figs: {} -> find the last test with ' "
           "python tests.py -v' and add a '@cleanup' decorator.")
    assert len(plt.get_fignums()) == 0, msg.format(plt.get_fignums())

def _setup_matplotlib ():
    import matplotlib, os

    if matplotlib.get_backend () == 'MacOSX':
        matplotlib.use ('TkAgg')
    if 'DISPLAY' not in os.environ and matplotlib.get_backend () == 'TkAgg':
        matplotlib.use ('Agg')

def test_create_figure():
    if matplotlib.get_backend() == "agg":
        pytest.xfail("{} backend does not support on_close event.".format(
            matplotlib.get_backend()))

    dummy_function = Mock()
    fig = utils.create_figure(window_title="test title",
                              _on_figure_window_close=dummy_function)
    assert isinstance(fig, matplotlib.figure.Figure) == True
    matplotlib.pyplot.close(fig)
    dummy_function.assert_called_once_with()

def plot_exemplary_roc(fname=None):
    if (fname is not None and mpl.get_backend() == u'pgf'):
        fileName, fileExtension = os.path.splitext(fname)
        if (fileExtension == "pdf"):
            pf.latexify()
        if(fileExtension == "pgf"):
            pf.latexifypgf()
    frange = [0.0, 1.0]
    magrange = [0.0, 1.0]
    fig, ax1 = pyplot.subplots()
    pf.format_axes(ax1)
    colors = pf.getColorList(7)
    pyplot.subplots_adjust(
        left=0.125, bottom=0.125, right=0.92, top=0.9, wspace=0.2, hspace=0.3)

    # add title, if given
    # pyplot.title("BI measurement with denoising ");
    npzfile = np.load(pf.data_dir() + 'exampleROC.npz')
    fpr = npzfile['fpr']
    tpr = npzfile['tpr']
    mean_fpr = npzfile['mean_fpr']
    pyplot.plot(fpr, tpr, color=colors[
                1], linestyle='-', linewidth=1.5, label="trained classifier")

    pyplot.plot(mean_fpr, mean_fpr, color=colors[5], linestyle='--', linewidth=1.5, label="random classifier")

    pf.modifyLegend(pyplot.legend(loc=4))
    # plot it as a log-scaled graph
    # update axis ranges
    ax_lim = []
    ax_lim[0:4] = pyplot.axis()
    # check if we were given a frequency range for the plot
    if (frange != None):
        ax_lim[0:2] = frange
    # check if we were given a dB range for the magnitude part of the plot
    # magrange = [0.2, 1.01]
    if (magrange != None):
        ax_lim[2:4] = magrange

    pyplot.axis(ax_lim)

    pyplot.grid(True)
    # turn on the minor gridlines to give that awesome log-scaled look
    pyplot.grid(True, which='minor')
    pyplot.xlabel("False positive rate")
    # pyplot.title("(b)");
    pyplot.ylabel("True positive rate")
    if (fname != None and mpl.get_backend() == u'pgf'):
        pyplot.savefig(fname, dpi=pf.getDpi())
    else:
        pyplot.show()

def redraw(figure):
    if 'inline' in matplotlib.get_backend():
        from IPython import display
        display.clear_output(wait=True)
        display.display(figure)
    else:
        plt.draw()

def mpl_test_settings(request):
    from matplotlib.testing.decorators import _do_cleanup

    original_units_registry = matplotlib.units.registry.copy()
    original_settings = matplotlib.rcParams.copy()

    backend = None
    backend_marker = request.keywords.get('backend')
    if backend_marker is not None:
        assert len(backend_marker.args) == 1, \
            "Marker 'backend' must specify 1 backend."
        backend = backend_marker.args[0]
        prev_backend = matplotlib.get_backend()

    style = '_classic_test'  # Default of cleanup and image_comparison too.
    style_marker = request.keywords.get('style')
    if style_marker is not None:
        assert len(style_marker.args) == 1, \
            "Marker 'style' must specify 1 style."
        style = style_marker.args[0]

    matplotlib.testing.setup()
    if backend is not None:
        # This import must come after setup() so it doesn't load the default
        # backend prematurely.
        import matplotlib.pyplot as plt
        plt.switch_backend(backend)
    matplotlib.style.use(style)
    try:
        yield
    finally:
        if backend is not None:
            plt.switch_backend(prev_backend)
        _do_cleanup(original_units_registry,
                    original_settings)

def software_stack():
    """
    Import all the hard dependencies.
    Returns a dict with the version.
    """
    # Mandatory
    import numpy, scipy

    d = dict(
        numpy=numpy.version.version,
        scipy=scipy.version.version,
    )

    # Optional but strongly suggested.
    try:
        import netCDF4, matplotlib
        d.update(dict(
            netCDF4=netCDF4.getlibversion(),
            matplotlib="Version: %s, backend: %s" % (matplotlib.__version__, matplotlib.get_backend()),
            ))
    except ImportError:
        pass

    # Optional (GUIs).
    try:
        import wx
        d["wx"] = wx.version()
    except ImportError:
        pass

    return d

    def __init__(self, dendrogram, hub, catalog, xaxis, yaxis):

        self.hub = hub
        self.dendrogram = dendrogram
        self.structures = list(self.dendrogram.all_structures)

        self.fig = plt.figure()
        self.axes = plt.subplot(1,1,1)

        self.catalog = catalog
        self.xdata = catalog[xaxis]
        self.ydata = catalog[yaxis]

        self.xys = np.column_stack((self.xdata, self.ydata))

        self.x_column_name = xaxis
        self.y_column_name = yaxis

        self.lines2d = {} # selection_id -> matplotlib.lines.Line2D

        # This is a workaround for a (likely) bug in matplotlib.widgets. Lasso crashes without this fix.
        if matplotlib.get_backend() == 'MacOSX':
            self.fig.canvas.supports_blit = False

        self._draw_plot()
        self.hub.add_callback(self.update_selection)

        self.cid = self.fig.canvas.mpl_connect('button_press_event', self.onpress)

        # If things are already selected in the hub, go select them!
        for selection_id in self.hub.selections:
            self.update_selection(selection_id)