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 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 __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. 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 _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 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 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 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 __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)
def __init__(self, draw_timestep=0.033333, facecolor=[1, 1, 1], figsize=None, ax=None): LeafSystem.__init__(self) self.set_name('pyplot_visualization') self.timestep = draw_timestep self.DeclarePeriodicPublish(draw_timestep, 0.0) if ax is None: (self.fig, self.ax) = plt.subplots(facecolor=facecolor, figsize=figsize) else: self.ax = ax self.fig = ax.get_figure() self.ax.axis('equal') self.ax.axis('off') self.record = False self.recorded_contexts = [] self.show = (matplotlib.get_backend().lower() != 'template') def on_initialize(context, event): if self.show: self.fig.show() self.DeclareInitializationEvent( event=PublishEvent( trigger_type=TriggerType.kInitialization, callback=on_initialize))
def set_mpl_backend(): try: from qtpy import PYQT5 except: # If Qt isn't available, we don't have to worry about # setting the backend return from matplotlib import rcParams, rcdefaults # standardize mpl setup rcdefaults() if PYQT5: rcParams['backend'] = 'Qt5Agg' else: rcParams['backend'] = 'Qt4Agg' # The following is a workaround for the fact that Matplotlib checks the # rcParams at import time, not at run-time. I have opened an issue with # Matplotlib here: https://github.com/matplotlib/matplotlib/issues/5513 from matplotlib import get_backend from matplotlib import backends backends.backend = get_backend()
def test_viz_scatter_scatter_xyid(self): fLOG(__file__, self._testMethodName, OutputPrint=__name__ == "__main__") if sys.version_info[:2] <= (3, 4): return fix_tkinter_issues_virtualenv() if __name__ == "__main__": rcParams["backend"] = "TkAgg" fold = os.path.abspath(os.path.split(__file__)[0]) fold = os.path.join(fold, "temp_graph_xyz") im = os.path.join(fold, self._testMethodName + ".png") if not os.path.exists(fold): os.mkdir(fold) for img in [im]: if os.path.exists(img): os.remove(img) nuage1 = self.generate_gauss(0, 0, 3) nuage2 = self.generate_gauss(3, 4, 2) nuage = [(a, b, 0) for a, b in nuage1] + [(a, b, 1) for a, b in nuage2] matplotlib.use(matplotlib.get_backend(), warn=False, force=True) fig, ax = scatter_xy_id( nuage, title=self._testMethodName, legend={0: "c0", 1: "c1"}) fig.savefig(im) assert os.path.exists(im) if __name__ == "__main__": rcParams["backend"] = TestMatplotlibHelperVizScatterPlots.backend plt.close('all') fLOG(plt.style.available)
def has_matplotlib(version=None, op=">="): """ True if matplotlib_ is installed. If version is None, the result of matplotlib.__version__ `op` version is returned. """ try: import matplotlib # have_display = "DISPLAY" in os.environ except ImportError: print("Skipping matplotlib test") return False matplotlib.use("Agg") #matplotlib.use("Agg", force=True) # Use non-graphical display backend during test. import matplotlib.pyplot as plt # http://stackoverflow.com/questions/21884271/warning-about-too-many-open-figures plt.close("all") backend = matplotlib.get_backend() if backend.lower() != "agg": #raise RuntimeError("matplotlib backend now is %s" % backend) #matplotlib.use("Agg", warn=True, force=False) # Switch the default backend. # This feature is experimental, and is only expected to work switching to an image backend. plt.switch_backend("Agg") if version is None: return True return cmp_version(matplotlib.__version__, version, op=op)
def software_stack(): """ Import all the hard dependencies. Returns ordered dict: package --> string with version info. """ # Mandatory import numpy, scipy, netCDF4, pymatgen, apscheduler, pydispatch, yaml d = collections.OrderedDict([ ("numpy", numpy.version.version), ("scipy", scipy.version.version), ("netCDF4", netCDF4.__version__), ("apscheduler", apscheduler.version), ("pydispatch", pydispatch.__version__), ("yaml", yaml.__version__), ("pymatgen", pymatgen.__version__), ]) # Optional but strongly suggested. try: import matplotlib d["matplotlib"] = "%s (backend: %s)" % (matplotlib.__version__, matplotlib.get_backend()) except ImportError: pass return d
def __enter__(self): """ Set matplotlib defaults. """ from matplotlib import get_backend, rcParams, rcdefaults import locale try: locale.setlocale(locale.LC_ALL, str('en_US.UTF-8')) except: try: locale.setlocale(locale.LC_ALL, str('English_United States.1252')) except: msg = "Could not set locale to English/United States. " + \ "Some date-related tests may fail" warnings.warn(msg) if get_backend().upper() != 'AGG': import matplotlib try: matplotlib.use('AGG', warn=False) except TypeError: msg = "Image comparison requires matplotlib backend 'AGG'" warnings.warn(msg) # set matplotlib builtin default settings for testing rcdefaults() rcParams['font.family'] = 'Bitstream Vera Sans' rcParams['text.hinting'] = False try: rcParams['text.hinting_factor'] = 8 except KeyError: warnings.warn("could not set rcParams['text.hinting_factor']") return self
def _acquire_externals(self, out): # Test and list all dependencies: sdeps = {True: [], False: [], 'Error': []} for dep in sorted(externals._KNOWN): try: sdeps[externals.exists(dep, force=False)] += [dep] except: sdeps['Error'] += [dep] out.write('EXTERNALS:\n') out.write(' Present: %s\n' % ', '.join(sdeps[True])) out.write(' Absent: %s\n' % ', '.join(sdeps[False])) if len(sdeps['Error']): out.write(' Errors in determining: %s\n' % ', '.join(sdeps['Error'])) SV = ('.__version__', ) # standard versioning out.write(' Versions of critical externals:\n') # First the ones known to externals, for k, v in sorted(externals.versions.iteritems()): out.write(' %-12s: %s\n' % (k, str(v))) try: if externals.exists('matplotlib'): import matplotlib out.write(' Matplotlib backend: %s\n' % matplotlib.get_backend()) except Exception, exc: out.write(' Failed to determine backend of matplotlib due to "%s"' % str(exc))
def ShowLastPos(plt): # Call plt.show but pickles the plot position on window close. When called a second time # it loads the figure to the last position. So matplotlib now remembers figure positions! # This version works for QT and WX backends. backend = matplotlib.get_backend() FigNums = plt.get_fignums() for FigNum in FigNums: plt.figure(FigNum) fig=plt.gcf() fig.canvas.mpl_connect('close_event', RecordLastPos) mgr = plt.get_current_fig_manager() # WX backend if 'WX' in backend: try: with open('CurrentWindowPos%d.pkl'%FigNum, 'r') as f: CurPos = pickle.load(f) mgr.window.SetPosition((CurPos[0], CurPos[1])) mgr.window.SetSize((CurPos[2], CurPos[3])) except: pass # QT backend. elif 'QT' in backend: try: with open('CurrentWindowPos%d.pkl'%FigNum, 'r') as f: CurPos = pickle.load(f) mgr.window.setGeometry(CurPos[0], CurPos[1], CurPos[2], CurPos[3]) except: pass else: print 'Backend ' + backend + ' not supported. Plot figure position will not be sticky.' plt.show()
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 _set_mpl_backend(): try: # We are doing local imports here to avoid poluting our namespace import matplotlib import os import sys # Set the backend to a non-interactive one for unices without X if ( os.name == "posix" and "DISPLAY" not in os.environ and not (sys.platform == "darwin" and matplotlib.get_backend() == "MacOSX") ): matplotlib.use("Agg") except ImportError: from .._utils.testing import skip_if_running_nose # No need to fail when running tests skip_if_running_nose("matplotlib not installed") raise else: from ..version import _import_module_with_version_check, OPTIONAL_MATPLOTLIB_MIN_VERSION # When matplotlib was successfully imported we need to check # that the version is greater that the minimum required one _import_module_with_version_check("matplotlib", OPTIONAL_MATPLOTLIB_MIN_VERSION)
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 _cleanup_cm with _cleanup_cm(): 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) with warnings.catch_warnings(): warnings.simplefilter("ignore", MatplotlibDeprecationWarning) matplotlib.style.use(style) try: yield finally: if backend is not None: plt.switch_backend(prev_backend)
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_mpl_mainprocess(verbose=VERBOSE_MPLINIT): global __IS_INITIALIZED__ global __WHO_INITIALIZED__ import matplotlib as mpl #mpl.interactive(True) current_backend = mpl.get_backend() target_backend = get_target_backend() if __IS_INITIALIZED__ is True: if verbose: print('[!plottool] matplotlib has already been initialized. backend=%r' % current_backend) print('[!plottool] Initially initialized by %r' % __WHO_INITIALIZED__) print('[!plottool] Trying to be init by %r' % (ut.get_caller_name(N=range(0, 5)))) return False __IS_INITIALIZED__ = True if verbose: print('[plottool] matplotlib initialized by %r' % __WHO_INITIALIZED__) __WHO_INITIALIZED__ = ut.get_caller_name(N=range(0, 5)) if verbose: print('--- INIT MPL---') print('[pt] current backend is: %r' % current_backend) print('[pt] mpl.use(%r)' % target_backend) if current_backend != target_backend: _mpl_set_backend(target_backend) _init_mpl_rcparams()
def setWindowRectangle(x, y=None, w=None, h=None, mngr=None, be=None): """ Position the current Matplotlib figure at the specified position """ if y is None: y = x[1] w = x[2] h = x[3] x = x[0] if mngr is None: mngr = plt.get_current_fig_manager() be = matplotlib.get_backend() if be == 'WXAgg': mngr.canvas.manager.window.SetPosition((x, y)) mngr.canvas.manager.window.SetSize((w, h)) elif be == 'agg': # mngr.canvas.manager.window.setGeometry(x,y,w,h) mngr.canvas.manager.window.SetPosition((x, y)) mngr.canvas.manager.window.resize(w, h) elif be == 'module://IPython.kernel.zmq.pylab.backend_inline': pass else: # assume Qt canvas mngr.canvas.manager.window.move(x, y) mngr.canvas.manager.window.resize(w, h) mngr.canvas.manager.window.setGeometry(x, y, w, h)
def check_for_modules(module_list): # make sure module_list only contains recognized modules unnamed_modules = set(module_list) - set(CMD_DICT.keys()) unnamed_modules = unnamed_modules - {'datetime', 're'} if unnamed_modules: msg = '\n\nThese modules unrecognized by check_for_modules(): ' msg += '{}\n'.format(unnamed_modules) raise ValueError(msg) # try using configured backend ignoring errors so they'll be caught later if set(module_list).intersection({'matplotlib', 'pylab', 'seaborn'}): CONFIG = config_lib.get_config() try: import matplotlib if matplotlib.get_backend() != CONFIG['plot_backend']: matplotlib.use(CONFIG['plot_backend']) except ImportError: pass # initialize an error message msg = '' # try importing all the required mojkdules for module in sorted(module_list): try: importlib.import_module(module) except ImportError: # add to error message for each bad module msg = msg if msg else HEADER msg += '-' * 60 + '\n' msg += "Missing module '{}'. To install use: \n".format(module) msg += " {}\n\n".format(CMD_DICT[module]) sys.stdout.write(msg + '\n') raise
def switch_backend(backend, sloppy=True): """ Switch matplotlib backend. :type backend: str :param backend: Name of matplotlib backend to switch to. :type sloppy: bool :param sloppy: If ``True``, only uses :func:`matplotlib.pyplot.switch_backend` and no warning will be shown if the backend was not switched successfully. If ``False``, additionally tries to use :func:`matplotlib.use` first and also shows a warning if the backend was not switched successfully. """ import matplotlib # sloppy. only do a `plt.switch_backend(..)` if sloppy: import matplotlib.pyplot as plt plt.switch_backend(backend) else: # check if `matplotlib.use(..)` is emitting a warning try: with warnings.catch_warnings(record=True): warnings.simplefilter("error", UserWarning) matplotlib.use(backend) # if that's the case, follow up with `plt.switch_backend(..)` except UserWarning: import matplotlib.pyplot as plt plt.switch_backend(backend) # finally check if the switch was successful, # show a warning if not if matplotlib.get_backend().upper() != backend.upper(): msg = "Unable to change matplotlib backend to '%s'" % backend warnings.warn(msg)
def _get_cursor_endpoints(self): import matplotlib as mpl # to get cursor position: # 1) change text to chars left of the cursor # 2) if macos, redraw # 3) get extent of temporary text box # 4) place cursor at appropriate place text = self.text.get_text() self.text.set_text(text[:self._cursorpos]) if mpl.get_backend() == 'MacOSX': # self.text can't get_window_extent() until drawn # this introduces some lag, so only do it on macos # apparently the GCContext gets invalidated when you set_text, so # you always have to do this self.canvas.draw() bbox = self.text.get_window_extent() l, b, w, h = bbox.bounds # in pixels r = l + w # now restore correct text self.text.set_text(text) # cursor line in data coordinates bx, by = self.ax.transAxes.inverted().transform((r, b)) tx, ty = self.ax.transAxes.inverted().transform((r, b + h)) dy = 0.5 * (ty - by) return [bx, tx], [by - dy, ty + dy]
def pulse_drawer( data: Union[Waveform, Union[Schedule, Instruction]], dt: int = 1, style: Union[PulseStyle, SchedStyle] = None, filename: str = None, interp_method: Callable = None, scale: float = None, channel_scales: Dict[Channel, float] = None, plot_all: bool = False, plot_range: Tuple[Union[int, float], Union[int, float]] = None, interactive: bool = False, table: bool = False, label: bool = False, framechange: bool = True, channels: List[Channel] = None, show_framechange_channels: bool = True, draw_title: bool = False, ): """Deprecated. Plot the interpolated envelope of pulse and schedule. Args: data: Pulse or schedule object to plot. dt: Time interval of samples. Pulses are visualized in the unit of cycle time if not provided. style: A style sheet to configure plot appearance. See :mod:`~qiskit.visualization.pulse.qcstyle` for more information. filename: Name required to save pulse image. The drawer just returns `matplot.Figure` object if not provided. interp_method: Interpolation function. Interpolation is disabled in default. See :mod:`~qiskit.visualization.pulse.interpolation` for more information. scale: Scaling of waveform amplitude. Pulses are automatically scaled channel by channel if not provided. channel_scales: Dictionary of scale factor for specific channels. Scale of channels not specified here is overwritten by `scale`. plot_all: When set `True` plot empty channels. plot_range: A tuple of time range to plot. interactive: When set `True` show the circuit in a new window. This depends on the matplotlib backend being used supporting this. table: When set `True` draw event table for supported commands. label: When set `True` draw label for individual instructions. framechange: When set `True` draw framechange indicators. channels: A list of channel names to plot. All non-empty channels are shown if not provided. show_framechange_channels: When set `True` plot channels with only framechange instructions. draw_title: Add a title to the plot when set to ``True``. Returns: matplotlib.figure.Figure: A matplotlib figure object for the pulse envelope. Example: This example shows how to visualize your pulse schedule. Pulse names are added to the plot, unimportant channels are removed and the time window is truncated to draw out U3 pulse sequence of interest. .. jupyter-execute:: import numpy as np import qiskit from qiskit import pulse from qiskit.test.mock.backends.almaden import FakeAlmaden inst_map = FakeAlmaden().defaults().instruction_schedule_map sched = pulse.Schedule() sched += inst_map.get('u3', 0, np.pi, 0, np.pi) sched += inst_map.get('measure', list(range(20))) << sched.duration channels = [pulse.DriveChannel(0), pulse.MeasureChannel(0)] scales = {pulse.DriveChannel(0): 10} qiskit.visualization.pulse_drawer(sched, channels=channels, plot_range=(0, 1000), label=True, channel_scales=scales) You are also able to call visualization module from the instance method:: sched.draw(channels=channels, plot_range=(0, 1000), label=True, channel_scales=scales) To customize the format of the schedule plot, you can setup your style sheet. .. jupyter-execute:: import numpy as np import qiskit from qiskit import pulse from qiskit.test.mock.backends.almaden import FakeAlmaden inst_map = FakeAlmaden().defaults().instruction_schedule_map sched = pulse.Schedule() sched += inst_map.get('u3', 0, np.pi, 0, np.pi) sched += inst_map.get('measure', list(range(20))) << sched.duration # setup style sheet my_style = qiskit.visualization.SchedStyle( figsize = (10, 5), bg_color='w', d_ch_color = ['#32cd32', '#556b2f']) channels = [pulse.DriveChannel(0), pulse.MeasureChannel(0)] scales = {pulse.DriveChannel(0): 10} qiskit.visualization.pulse_drawer(sched, style=my_style, channels=channels, plot_range=(0, 1000), label=True, channel_scales=scales) Raises: VisualizationError: when invalid data is given MissingOptionalLibraryError: when matplotlib is not installed """ warnings.warn( "This legacy pulse drawer is deprecated and will be removed no earlier than " "3 months after the release date. Use `qiskit.visualization.pulse_drawer_v2` " "instead. After the legacy drawer is removed, the import path of this module " "will be dedicated to the v2 drawer. " "New drawer will provide much more flexibility with richer stylesheets " "and cleaner visualization.", DeprecationWarning, ) if not HAS_MATPLOTLIB: raise MissingOptionalLibraryError( libname="Matplotlib", name="pulse_drawer", pip_install="pip install matplotlib", ) from matplotlib import get_backend from matplotlib import pyplot as plt if isinstance(data, Waveform): drawer = _matplotlib.WaveformDrawer(style=style) image = drawer.draw(data, dt=dt, interp_method=interp_method, scale=scale) elif isinstance(data, (Schedule, Instruction)): drawer = _matplotlib.ScheduleDrawer(style=style) image = drawer.draw( data, dt=dt, interp_method=interp_method, scale=scale, channel_scales=channel_scales, plot_range=plot_range, plot_all=plot_all, table=table, label=label, framechange=framechange, channels=channels, show_framechange_channels=show_framechange_channels, draw_title=draw_title, ) else: raise VisualizationError("This data cannot be visualized.") if filename: image.savefig(filename, dpi=drawer.style.dpi, bbox_inches="tight") if get_backend() in ["module://ipykernel.pylab.backend_inline", "nbAgg"]: plt.close(image) if image and interactive: image.show() return image
#------------------------------ # Module's version from CVS -- #------------------------------ __version__ = "$Revision: 4 $" # $Source$ #-------------------------------- # Imports of standard modules -- #-------------------------------- import sys import os import matplotlib #matplotlib.use('Qt4Agg') # forse Agg rendering to a Qt4 canvas (backend) if matplotlib.get_backend() != 'Qt4Agg': matplotlib.use('Qt4Agg') from PyQt4 import QtGui, QtCore #import time # for sleep(sec) #----------------------------- # Imports for other modules -- #----------------------------- from ConfigParametersForApp import cp from Logger import logger from FileNameManager import fnm from CorAna.MaskEditor import MaskEditor import GlobalUtils as gu
import matplotlib import math import random import matplotlib.pyplot as plt import torch import torch.nn as nn import torch.optim as optim import torch.nn.functional as F import torchvision.transform as T device = torch.device("cuda" if torch.cuda.is_available() else "cpu") env = gym.make("").unwrapped is_ipytohn = "inline" in matplotlib.get_backend() if is_ipython: from IPython import display plt.ion() class replay_memories(object): def __init__(self, capacity): self.capacity = capacity self.memory = [] self.position = 0 def push(self, *args): if len(self.memory) < self.capacity: self.memory.append(None)
# coding: utf-8 # In[ ]: #!/usr/bin/env python from pywps.Process import WPSProcess import logging import matplotlib logging.info('get backend before set') print('get backend before set') logging.info(matplotlib.matplotlib_fname()) print(matplotlib.matplotlib_fname()) logging.info(matplotlib.get_backend()) print(matplotlib.get_backend()) matplotlib.rcParams['backend'] = 'AGG' matplotlib.use('AGG') logging.info('get backend after set') logging.info(matplotlib.get_backend()) import sys import matplotlib.pyplot as plt import cartopy.crs as ccrs from cartopy.mpl.gridliner import LATITUDE_FORMATTER, LONGITUDE_FORMATTER import matplotlib.ticker as mticker import matplotlib.colors as mcolors import matplotlib.colorbar as mcb import cartopy.feature as cfeature
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import io from multiprocessing import Process, Manager import matplotlib import matplotlib.pyplot as plt import numpy as np from mpl_toolkits.basemap import Basemap from . import BaseDomsHandler from . import ResultsStorage if not matplotlib.get_backend(): matplotlib.use('Agg') PARAMETER_TO_FIELD = { "sst": "sea_water_temperature", "sss": "sea_water_salinity" } PARAMETER_TO_UNITS = {"sst": "($^\circ$ C)", "sss": "(g/L)"} def __square(minLon, maxLon, minLat, maxLat): if maxLat - minLat > maxLon - minLon: a = ((maxLat - minLat) - (maxLon - minLon)) / 2.0 minLon -= a maxLon += a
#!/usr/bin/env python import sys import matplotlib if matplotlib.get_backend() != "TKAgg": matplotlib.use("TKAgg") import pmagpy.pmag as pmag import pmagpy.pmagplotlib as pmagplotlib def main(): """ NAME lowrie_magic.py DESCRIPTION plots intensity decay curves for Lowrie experiments SYNTAX lowrie_magic.py -h [command line options] INPUT takes measurements formatted input files OPTIONS -h prints help message and quits -f FILE: specify input file, default is magic_measurements.txt -N do not normalize by maximum magnetization -fmt [svg, pdf, eps, png] specify fmt, default is svg -sav saves plots and quits -DM [2, 3] MagIC data model number
import os import subprocess from multiprocessing import Process from packaging import version import matplotlib from matplotlib import animation BACKEND = 'Agg' if matplotlib.get_backend().lower() != BACKEND.lower(): matplotlib.use(BACKEND) import matplotlib.pyplot as plt def save_animation(filepath, shp, ds, color): print("Starting to generate %s" % filepath) fig = plt.figure() ax = fig.add_axes([0.1, 0.1, 0.8, 0.8]) ims = [] print("Generating images.") for i in range(0, shp[2]): ttl = plt.text(0.5, 1.01, "Depth: %s" % i, horizontalalignment='center', verticalalignment='bottom', transform=ax.transAxes) im = plt.imshow(ds['v'][:, :, i], animated=True, cmap=color) plt.xlabel("x") plt.ylabel("y") ims.append([im, ttl]) print("Generating animation.") ani = animation.ArtistAnimation(fig, ims, interval=50, blit=True)
import matplotlib import matplotlib.pyplot as plt from collections import namedtuple from itertools import count from PIL import Image import torch import torch.nn as nn import torch.optim as optim import torch.nn.functional as F import torchvision.transforms as T env = gym.make('CartPole-v0').unwrapped #set up matplotlib is_ipython = 'inline' in matplotlib.get_backend() if is_ipython: from IPython import display plt.ion() #if gup is to be used device = torch.device('cuda' if torch.cuda.is_available() else "cpu") #回放记忆 Transition = namedtuple('Transition', ('state', 'action', 'next_state', 'reward')) class ReplayMemory(object): def __init__(self, capacity): self.capacity = capacity self.memory = []
def _is_notebook_inline_backend(): return _is_jupyter_notebook() and 'backend_inline' in mpl.get_backend()
from __future__ import absolute_import from __future__ import division from __future__ import print_function import re import numpy as np from collections import OrderedDict import matplotlib if matplotlib.get_backend() != 'module://backend_interagg': matplotlib.use("TkAgg") from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg import matplotlib.pyplot as plt from mpl_toolkits.axes_grid1 import make_axes_locatable import tkinter as tk from tkinter import ttk from tkinter import Frame from tframe import console from tframe.utils.tensor_viewer.plugin import Plugin, VariableWithView class VariableViewer(Frame): # Configurations of VariableViewer widget WIDTH = 500 HEIGHT = 500 def __init__(self, master): # Call parent's constructor Frame.__init__(self, master)
def transform_epochs(self, X, warm_start=False, scaling=1, save=False, verbose=True): orig_mpl_backend = matplotlib.get_backend() matplotlib.use("agg") X = X.get_data() * scaling # X = X / X.transpose(1, 0, 2).reshape(X.shape[1], -1).std(axis=1)[np.newaxis, :, np.newaxis] n_epochs, n_channels, n_times = X.shape X_filtered = X.copy() if not warm_start: self.m = self.m_0 self.w = self.w_0 self.lambdas = [self.lw_0] self.sigmas = list() im_cnt = 0 epoch_iter = range(n_epochs) if verbose: epoch_iter = tqdm(epoch_iter) for e in epoch_iter: window_iter = range(self.size_block, n_times + self.stride, self.stride) if verbose: window_iter = tqdm(window_iter, leave=False) for i in window_iter: X_i = X[e, :, i - self.size_block:i] n_p = X_i.shape[1] for n_pass in range(self.n_passes): lm, lw, sigma = self.get_lambdas(X_i, e * n_times + i, self.m, self.w) # print(e, n_times, e * n_times + i, max(lm), min(lm)) m = update_m(X_i, self.m, lambdas=lm) w = update_w_block(self.m @ X_i, self.w, lambdas=lw, n_sub=self.n_sub) self.m, self.w = m, w y = self.w @ self.m @ X_i X_filtered[e, :, i - self.size_block:i] = y self.lambdas.append(lw.mean()) self.sigmas.append(sigma) if ((i % 100) < self.stride) and save: fig = plt.figure(figsize=(9, 9)) plt.imshow(self.m) plt.colorbar() fig.savefig("./m/img_{}.png".format(str(im_cnt).rjust(5, "0"))) plt.close(fig) del fig fig = plt.figure(figsize=(9, 9)) plt.imshow(self.w) plt.colorbar() fig.savefig("./w/img_{}.png".format(str(im_cnt).rjust(5, "0"))) plt.close(fig) del fig fig = plt.figure(figsize=(9, 9)) plt.imshow(np.corrcoef(self.m @ X_i)) plt.colorbar() fig.savefig("./c/img_{}.png".format(str(im_cnt).rjust(5, "0"))) plt.close(fig) del fig plt.close("all") im_cnt += 1 matplotlib.use(orig_mpl_backend) return X_filtered
def plot_state_qsphere(state, figsize=None, ax=None, show_state_labels=True, show_state_phases=False, use_degrees=False, *, rho=None): """Plot the qsphere representation of a quantum state. Here, the size of the points is proportional to the probability of the corresponding term in the state and the color represents the phase. Args: state (Statevector or DensityMatrix or ndarray): an N-qubit quantum state. figsize (tuple): Figure size in inches. ax (matplotlib.axes.Axes): An optional Axes object to be used for the visualization output. If none is specified a new matplotlib Figure will be created and used. Additionally, if specified there will be no returned Figure since it is redundant. show_state_labels (bool): An optional boolean indicating whether to show labels for each basis state. show_state_phases (bool): An optional boolean indicating whether to show the phase for each basis state. use_degrees (bool): An optional boolean indicating whether to use radians or degrees for the phase values in the plot. Returns: Figure: A matplotlib figure instance if the ``ax`` kwag is not set Raises: ImportError: Requires matplotlib. VisualizationError: if input is not a valid N-qubit state. QiskitError: Input statevector does not have valid dimensions. Example: .. jupyter-execute:: from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector from qiskit.visualization import plot_state_qsphere %matplotlib inline qc = QuantumCircuit(2) qc.h(0) qc.cx(0, 1) state = Statevector.from_instruction(qc) plot_state_qsphere(state) """ if not HAS_MATPLOTLIB: raise ImportError('Must have Matplotlib installed. To install, run "pip install ' 'matplotlib".') try: import seaborn as sns except ImportError: raise ImportError('Must have seaborn installed to use ' 'plot_state_qsphere. To install, run "pip install seaborn".') rho = DensityMatrix(state) num = rho.num_qubits if num is None: raise VisualizationError("Input is not a multi-qubit quantum state.") # get the eigenvectors and eigenvalues eigvals, eigvecs = linalg.eigh(rho.data) if figsize is None: figsize = (7, 7) if ax is None: return_fig = True fig = plt.figure(figsize=figsize) else: return_fig = False fig = ax.get_figure() gs = gridspec.GridSpec(nrows=3, ncols=3) ax = fig.add_subplot(gs[0:3, 0:3], projection='3d') ax.axes.set_xlim3d(-1.0, 1.0) ax.axes.set_ylim3d(-1.0, 1.0) ax.axes.set_zlim3d(-1.0, 1.0) ax.axes.grid(False) ax.view_init(elev=5, azim=275) # start the plotting # Plot semi-transparent sphere u = np.linspace(0, 2 * np.pi, 25) v = np.linspace(0, np.pi, 25) x = np.outer(np.cos(u), np.sin(v)) y = np.outer(np.sin(u), np.sin(v)) z = np.outer(np.ones(np.size(u)), np.cos(v)) ax.plot_surface(x, y, z, rstride=1, cstride=1, color='k', alpha=0.05, linewidth=0) # Get rid of the panes ax.w_xaxis.set_pane_color((1.0, 1.0, 1.0, 0.0)) ax.w_yaxis.set_pane_color((1.0, 1.0, 1.0, 0.0)) ax.w_zaxis.set_pane_color((1.0, 1.0, 1.0, 0.0)) # Get rid of the spines ax.w_xaxis.line.set_color((1.0, 1.0, 1.0, 0.0)) ax.w_yaxis.line.set_color((1.0, 1.0, 1.0, 0.0)) ax.w_zaxis.line.set_color((1.0, 1.0, 1.0, 0.0)) # Get rid of the ticks ax.set_xticks([]) ax.set_yticks([]) ax.set_zticks([]) # traversing the eigvals/vecs backward as sorted low->high for idx in range(eigvals.shape[0]-1, -1, -1): if eigvals[idx] > 0.001: # get the max eigenvalue state = eigvecs[:, idx] loc = np.absolute(state).argmax() # remove the global phase from max element angles = (np.angle(state[loc]) + 2 * np.pi) % (2 * np.pi) angleset = np.exp(-1j * angles) state = angleset * state d = num for i in range(2 ** num): # get x,y,z points element = bin(i)[2:].zfill(num) weight = element.count("1") zvalue = -2 * weight / d + 1 number_of_divisions = n_choose_k(d, weight) weight_order = bit_string_index(element) angle = (float(weight) / d) * (np.pi * 2) + \ (weight_order * 2 * (np.pi / number_of_divisions)) if (weight > d / 2) or ((weight == d / 2) and (weight_order >= number_of_divisions / 2)): angle = np.pi - angle - (2 * np.pi / number_of_divisions) xvalue = np.sqrt(1 - zvalue ** 2) * np.cos(angle) yvalue = np.sqrt(1 - zvalue ** 2) * np.sin(angle) # get prob and angle - prob will be shade and angle color prob = np.real(np.dot(state[i], state[i].conj())) if prob > 1: # See https://github.com/Qiskit/qiskit-terra/issues/4666 prob = 1 colorstate = phase_to_rgb(state[i]) alfa = 1 if yvalue >= 0.1: alfa = 1.0 - yvalue if not np.isclose(prob, 0) and show_state_labels: rprime = 1.3 angle_theta = np.arctan2(np.sqrt(1 - zvalue ** 2), zvalue) xvalue_text = rprime * np.sin(angle_theta) * np.cos(angle) yvalue_text = rprime * np.sin(angle_theta) * np.sin(angle) zvalue_text = rprime * np.cos(angle_theta) element_text = '$\\vert' + element + '\\rangle$' if show_state_phases: element_angle = (np.angle(state[i]) + (np.pi * 4)) % (np.pi * 2) if use_degrees: element_text += '\n$%.1f^\\circ$' % (element_angle * 180/np.pi) else: element_angle = pi_check(element_angle, ndigits=3).replace('pi', '\\pi') element_text += '\n$%s$' % (element_angle) ax.text(xvalue_text, yvalue_text, zvalue_text, element_text, ha='center', va='center', size=12) ax.plot([xvalue], [yvalue], [zvalue], markerfacecolor=colorstate, markeredgecolor=colorstate, marker='o', markersize=np.sqrt(prob) * 30, alpha=alfa) a = Arrow3D([0, xvalue], [0, yvalue], [0, zvalue], mutation_scale=20, alpha=prob, arrowstyle="-", color=colorstate, lw=2) ax.add_artist(a) # add weight lines for weight in range(d + 1): theta = np.linspace(-2 * np.pi, 2 * np.pi, 100) z = -2 * weight / d + 1 r = np.sqrt(1 - z ** 2) x = r * np.cos(theta) y = r * np.sin(theta) ax.plot(x, y, z, color=(.5, .5, .5), lw=1, ls=':', alpha=.5) # add center point ax.plot([0], [0], [0], markerfacecolor=(.5, .5, .5), markeredgecolor=(.5, .5, .5), marker='o', markersize=3, alpha=1) else: break n = 64 theta = np.ones(n) ax2 = fig.add_subplot(gs[2:, 2:]) ax2.pie(theta, colors=sns.color_palette("hls", n), radius=0.75) ax2.add_artist(Circle((0, 0), 0.5, color='white', zorder=1)) offset = 0.95 # since radius of sphere is one. if use_degrees: labels = ['Phase\n(Deg)', '0', '90', '180 ', '270'] else: labels = ['Phase', '$0$', '$\\pi/2$', '$\\pi$', '$3\\pi/2$'] ax2.text(0, 0, labels[0], horizontalalignment='center', verticalalignment='center', fontsize=14) ax2.text(offset, 0, labels[1], horizontalalignment='center', verticalalignment='center', fontsize=14) ax2.text(0, offset, labels[2], horizontalalignment='center', verticalalignment='center', fontsize=14) ax2.text(-offset, 0, labels[3], horizontalalignment='center', verticalalignment='center', fontsize=14) ax2.text(0, -offset, labels[4], horizontalalignment='center', verticalalignment='center', fontsize=14) if return_fig: if get_backend() in ['module://ipykernel.pylab.backend_inline', 'nbAgg']: plt.close(fig) return fig
# Import Python modules import os import sys import math import atexit import shutil import tempfile import numpy as np import subprocess from scipy import interpolate from scipy.signal import sosfiltfilt, filtfilt, ellip, butter, kaiser, zpk2sos, decimate from scipy.signal.windows import tukey from scipy.integrate import cumtrapz import matplotlib as mpl if mpl.get_backend() != 'agg': mpl.use('Agg') # Disables use of Tk/X11 import matplotlib.pyplot as plt import pylab # This is used to convert from accel in g to accel in cm/s/s G2CMSS = 980.665 # Convert g to cm/s/s def cleanup(dir_name): """ This function removes the temporary directory """ shutil.rmtree(dir_name)
def mpl_test_settings(request): from matplotlib.testing.decorators import _cleanup_cm with _cleanup_cm(): backend = None backend_marker = request.node.get_closest_marker('backend') if backend_marker is not None: assert len(backend_marker.args) == 1, \ "Marker 'backend' must specify 1 backend." backend, = backend_marker.args skip_on_importerror = backend_marker.kwargs.get( 'skip_on_importerror', False) prev_backend = matplotlib.get_backend() # special case Qt backend importing to avoid conflicts if backend.lower().startswith('qt4'): if any(k in sys.modules for k in ('PyQt5', 'PySide2')): pytest.skip('Qt5 binding already imported') try: import PyQt4 # RuntimeError if PyQt5 already imported. except (ImportError, RuntimeError): try: import PySide except ImportError: pytest.skip("Failed to import a Qt4 binding.") elif backend.lower().startswith('qt5'): if any(k in sys.modules for k in ('PyQt4', 'PySide')): pytest.skip('Qt4 binding already imported') try: import PyQt5 # RuntimeError if PyQt4 already imported. except (ImportError, RuntimeError): try: import PySide2 except ImportError: pytest.skip("Failed to import a Qt5 binding.") # Default of cleanup and image_comparison too. style = ["classic", "_classic_test_patch"] style_marker = request.node.get_closest_marker('style') if style_marker is not None: assert len(style_marker.args) == 1, \ "Marker 'style' must specify 1 style." style, = style_marker.args 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 try: plt.switch_backend(backend) except ImportError as exc: # Should only occur for the cairo backend tests, if neither # pycairo nor cairocffi are installed. if 'cairo' in backend.lower() or skip_on_importerror: pytest.skip("Failed to switch to backend {} ({}).".format( backend, exc)) else: raise with cbook._suppress_matplotlib_deprecation_warning(): matplotlib.style.use(style) try: yield finally: if backend is not None: plt.switch_backend(prev_backend)
import ekf import imm import pda import estimationstatistics as estats # %% plot config check and style setup # to see your plot config print(f"matplotlib backend: {matplotlib.get_backend()}") print(f"matplotlib config file: {matplotlib.matplotlib_fname()}") print(f"matplotlib config dir: {matplotlib.get_configdir()}") plt.close("all") # try to set separate window ploting if "inline" in matplotlib.get_backend(): print("Plotting is set to inline at the moment:", end=" ") if "ipykernel" in matplotlib.get_backend(): print("backend is ipykernel (IPython?)") print("Trying to set backend to separate window:", end=" ") import IPython IPython.get_ipython().run_line_magic("matplotlib", "") else: print("unknown inline backend") print("continuing with this plotting backend", end="\n\n\n") # set styles
import pandas as pd import matplotlib.pyplot as plt import matplotlib from matplotlib.patches import Rectangle matplotlib.get_backend() matplotlib.use('TkAgg') import dateutil.parser as parser file_path = 'G:/Semester 8/FYP2/dataset/users/users_part.tsv' users = pd.read_csv(file_path, sep='\t') # display more width and columns desired_width = 320 pd.set_option('display.width', desired_width) pd.set_option('display.max_columns', None) # Unique values unique_managed_others = users.ManagedOthers.unique() print('Managed Others Unique Values', unique_managed_others) # Bar Graph counts = users.ManagedOthers.value_counts() output = plt.bar(counts.index, counts.values, ec='black', width=0.5) cmap = plt.get_cmap('jet') color1 = cmap(0.25) color2 = cmap(0.75) output[0].set_facecolor(color1) output[1].set_facecolor(color2)
def PlottingBackend_Switch(whichBackEnd): import matplotlib matplotlib.use(whichBackEnd, warn=False, force=True) from matplotlib import pyplot as plt print "Switched to:", matplotlib.get_backend()
def main(filename, outfile="stdout", verbose=3): """Method to call ahkab from a Python script with a netlist file. **Parameters:** filename : string The netlist filename. outfile : string, optional The outfiles base name, the suffixes shown below will be added. With the exception of the magic value ``stdout`` which causes ahkab to print out instead of to disk. verbose : int, optional the verbosity level, from 0 (silent) to 6 (debug). It defaults to 3, the same as running ahkab through its command line interface. Filename suffixes, for each analysis: - Alternate Current (AC): ``.ac`` - Direct Current (DC): ``.dc`` - Operating Point (OP): ``.opinfo`` - Periodic Steady State (PSS): ``.pss`` - Pole-zero Analysis (PZ): ``.pz`` - TRANsient (TRAN): ``.tran`` - Symbolic: ``.symbolic`` **Returns:** res : dict A dictionary containing the computed results. """ printing.print_info_line( ("This is ahkab %s running with:" % (__version__), 6), verbose) printing.print_info_line( (" Python %s" % (sys.version.split('\n')[0],), 6), verbose) printing.print_info_line((" Numpy %s" % (np.__version__), 6), verbose) printing.print_info_line((" Scipy %s" % (sp.__version__), 6), verbose) printing.print_info_line((" Sympy %s" % (sympy.__version__), 6), verbose) printing.print_info_line((" Tabulate %s" % (tabulate.__version__), 6), verbose) if plotting_available: printing.print_info_line((" Matplotlib %s" % (matplotlib.__version__), 6), verbose) printing.print_info_line((" -> backend: %s" % (matplotlib.get_backend()), 6), verbose) printing.print_info_line((" -> matplotlibrc: %s" % (matplotlib.matplotlib_fname()), 6), verbose) else: printing.print_info_line( (" Matplotlib not found.", 6), verbose) read_netlist_from_stdin = (filename is None or filename == "-") (circ, directives, postproc_direct) = netlist_parser.parse_circuit( filename, read_netlist_from_stdin) printing.print_info_line(("Checking circuit for common mistakes...", 6), verbose, print_nl=False) check, reason = utilities.check_circuit(circ) if not check: printing.print_general_error(reason) sys.exit(3) printing.print_info_line(("done.", 6), verbose) if verbose > 3 or _print: print("Parsed circuit:") print(circ) print("Models:") for m in circ.models: circ.models[m].print_model() print("") ic_list = netlist_parser.parse_ics(directives) _handle_netlist_ics(circ, an_list=[], ic_list=ic_list) results = {} for an in netlist_parser.parse_analysis(circ, directives): if 'outfile' not in list(an.keys()) or not an['outfile']: an.update( {'outfile': outfile + ("." + an['type']) * (outfile != 'stdout')}) if 'verbose' in list(an.keys()) and (an['verbose'] is None or an['verbose'] < verbose) \ or not 'verbose' in list(an.keys()): an.update({'verbose': verbose}) _handle_netlist_ics(circ, [an], ic_list=[]) if verbose >= 4: printing.print_info_line(("Requested an.:", 4), verbose) printing.print_analysis(an) results.update(run(circ, [an])) postproc_list = netlist_parser.parse_postproc(circ, postproc_direct) if len(postproc_list) > 0 and len(results): process_postproc(postproc_list, circ.title, results, outfile) return results
def plot_state_hinton(state, title='', figsize=None, ax_real=None, ax_imag=None, *, rho=None): """Plot a hinton diagram for the density matrix of a quantum state. Args: state (Statevector or DensityMatrix or ndarray): An N-qubit quantum state. title (str): a string that represents the plot title figsize (tuple): Figure size in inches. ax_real (matplotlib.axes.Axes): An optional Axes object to be used for the visualization output. If none is specified a new matplotlib Figure will be created and used. If this is specified without an ax_imag only the real component plot will be generated. Additionally, if specified there will be no returned Figure since it is redundant. ax_imag (matplotlib.axes.Axes): An optional Axes object to be used for the visualization output. If none is specified a new matplotlib Figure will be created and used. If this is specified without an ax_imag only the real component plot will be generated. Additionally, if specified there will be no returned Figure since it is redundant. Returns: matplotlib.Figure: The matplotlib.Figure of the visualization if neither ax_real or ax_imag is set. Raises: ImportError: Requires matplotlib. VisualizationError: if input is not a valid N-qubit state. Example: .. jupyter-execute:: from qiskit import QuantumCircuit from qiskit.quantum_info import DensityMatrix from qiskit.visualization import plot_state_hinton %matplotlib inline qc = QuantumCircuit(2) qc.h(0) qc.cx(0, 1) state = DensityMatrix.from_instruction(qc) plot_state_hinton(state, title="New Hinton Plot") """ if not HAS_MATPLOTLIB: raise ImportError('Must have Matplotlib installed. To install, run ' '"pip install matplotlib".') # Figure data rho = DensityMatrix(state) num = rho.num_qubits if num is None: raise VisualizationError("Input is not a multi-qubit quantum state.") max_weight = 2 ** np.ceil(np.log(np.abs(rho.data).max()) / np.log(2)) datareal = np.real(rho.data) dataimag = np.imag(rho.data) if figsize is None: figsize = (8, 5) if not ax_real and not ax_imag: fig, (ax1, ax2) = plt.subplots(1, 2, figsize=figsize) else: if ax_real: fig = ax_real.get_figure() else: fig = ax_imag.get_figure() ax1 = ax_real ax2 = ax_imag column_names = [bin(i)[2:].zfill(num) for i in range(2**num)] row_names = [bin(i)[2:].zfill(num) for i in range(2**num)] ly, lx = datareal.shape # Real if ax1: ax1.patch.set_facecolor('gray') ax1.set_aspect('equal', 'box') ax1.xaxis.set_major_locator(plt.NullLocator()) ax1.yaxis.set_major_locator(plt.NullLocator()) for (x, y), w in np.ndenumerate(datareal): color = 'white' if w > 0 else 'black' size = np.sqrt(np.abs(w) / max_weight) rect = plt.Rectangle([x - size / 2, y - size / 2], size, size, facecolor=color, edgecolor=color) ax1.add_patch(rect) ax1.set_xticks(np.arange(0, lx+0.5, 1)) ax1.set_yticks(np.arange(0, ly+0.5, 1)) row_names.append('') ax1.set_yticklabels(row_names, fontsize=14) column_names.append('') ax1.set_xticklabels(column_names, fontsize=14, rotation=90) ax1.autoscale_view() ax1.invert_yaxis() ax1.set_title('Re[$\\rho$]', fontsize=14) # Imaginary if ax2: ax2.patch.set_facecolor('gray') ax2.set_aspect('equal', 'box') ax2.xaxis.set_major_locator(plt.NullLocator()) ax2.yaxis.set_major_locator(plt.NullLocator()) for (x, y), w in np.ndenumerate(dataimag): color = 'white' if w > 0 else 'black' size = np.sqrt(np.abs(w) / max_weight) rect = plt.Rectangle([x - size / 2, y - size / 2], size, size, facecolor=color, edgecolor=color) ax2.add_patch(rect) ax2.set_xticks(np.arange(0, lx+0.5, 1)) ax2.set_yticks(np.arange(0, ly+0.5, 1)) ax2.set_yticklabels(row_names, fontsize=14) ax2.set_xticklabels(column_names, fontsize=14, rotation=90) ax2.autoscale_view() ax2.invert_yaxis() ax2.set_title('Im[$\\rho$]', fontsize=14) if title: fig.suptitle(title, fontsize=16) if ax_real is None and ax_imag is None: if get_backend() in ['module://ipykernel.pylab.backend_inline', 'nbAgg']: plt.close(fig) return fig
def plot_state_city(state, title="", figsize=None, color=None, alpha=1, ax_real=None, ax_imag=None, *, rho=None): """Plot the cityscape of quantum state. Plot two 3d bar graphs (two dimensional) of the real and imaginary part of the density matrix rho. Args: state (Statevector or DensityMatrix or ndarray): an N-qubit quantum state. title (str): a string that represents the plot title figsize (tuple): Figure size in inches. color (list): A list of len=2 giving colors for real and imaginary components of matrix elements. alpha (float): Transparency value for bars ax_real (matplotlib.axes.Axes): An optional Axes object to be used for the visualization output. If none is specified a new matplotlib Figure will be created and used. If this is specified without an ax_imag only the real component plot will be generated. Additionally, if specified there will be no returned Figure since it is redundant. ax_imag (matplotlib.axes.Axes): An optional Axes object to be used for the visualization output. If none is specified a new matplotlib Figure will be created and used. If this is specified without an ax_imag only the real component plot will be generated. Additionally, if specified there will be no returned Figure since it is redundant. Returns: matplotlib.Figure: The matplotlib.Figure of the visualization if the ``ax_real`` and ``ax_imag`` kwargs are not set Raises: ImportError: Requires matplotlib. ValueError: When 'color' is not a list of len=2. VisualizationError: if input is not a valid N-qubit state. Example: .. jupyter-execute:: from qiskit import QuantumCircuit from qiskit.quantum_info import DensityMatrix from qiskit.visualization import plot_state_city %matplotlib inline qc = QuantumCircuit(2) qc.h(0) qc.cx(0, 1) state = DensityMatrix.from_instruction(qc) plot_state_city(state, color=['midnightblue', 'midnightblue'], title="New State City") """ if not HAS_MATPLOTLIB: raise ImportError( 'Must have Matplotlib installed. To install, run "pip install ' 'matplotlib".') rho = DensityMatrix(state) num = rho.num_qubits if num is None: raise VisualizationError("Input is not a multi-qubit quantum state.") # get the real and imag parts of rho datareal = np.real(rho.data) dataimag = np.imag(rho.data) # get the labels column_names = [bin(i)[2:].zfill(num) for i in range(2**num)] row_names = [bin(i)[2:].zfill(num) for i in range(2**num)] lx = len(datareal[0]) # Work out matrix dimensions ly = len(datareal[:, 0]) xpos = np.arange(0, lx, 1) # Set up a mesh of positions ypos = np.arange(0, ly, 1) xpos, ypos = np.meshgrid(xpos + 0.25, ypos + 0.25) xpos = xpos.flatten() ypos = ypos.flatten() zpos = np.zeros(lx * ly) dx = 0.5 * np.ones_like(zpos) # width of bars dy = dx.copy() dzr = datareal.flatten() dzi = dataimag.flatten() if color is None: color = ["#648fff", "#648fff"] else: if len(color) != 2: raise ValueError("'color' must be a list of len=2.") if color[0] is None: color[0] = "#648fff" if color[1] is None: color[1] = "#648fff" if ax_real is None and ax_imag is None: # set default figure size if figsize is None: figsize = (15, 5) fig = plt.figure(figsize=figsize) ax1 = fig.add_subplot(1, 2, 1, projection='3d') ax2 = fig.add_subplot(1, 2, 2, projection='3d') elif ax_real is not None: fig = ax_real.get_figure() ax1 = ax_real if ax_imag is not None: ax2 = ax_imag else: fig = ax_imag.get_figure() ax1 = None ax2 = ax_imag max_dzr = max(dzr) min_dzr = min(dzr) min_dzi = np.min(dzi) max_dzi = np.max(dzi) if ax1 is not None: fc1 = generate_facecolors(xpos, ypos, zpos, dx, dy, dzr, color[0]) for idx, cur_zpos in enumerate(zpos): if dzr[idx] > 0: zorder = 2 else: zorder = 0 b1 = ax1.bar3d(xpos[idx], ypos[idx], cur_zpos, dx[idx], dy[idx], dzr[idx], alpha=alpha, zorder=zorder) b1.set_facecolors(fc1[6 * idx:6 * idx + 6]) xlim, ylim = ax1.get_xlim(), ax1.get_ylim() x = [xlim[0], xlim[1], xlim[1], xlim[0]] y = [ylim[0], ylim[0], ylim[1], ylim[1]] z = [0, 0, 0, 0] verts = [list(zip(x, y, z))] pc1 = Poly3DCollection(verts, alpha=0.15, facecolor='k', linewidths=1, zorder=1) if min(dzr) < 0 < max(dzr): ax1.add_collection3d(pc1) ax1.set_xticks(np.arange(0.5, lx + 0.5, 1)) ax1.set_yticks(np.arange(0.5, ly + 0.5, 1)) if max_dzr != min_dzr: ax1.axes.set_zlim3d(np.min(dzr), max(np.max(dzr) + 1e-9, max_dzi)) else: if min_dzr == 0: ax1.axes.set_zlim3d(np.min(dzr), max(np.max(dzr) + 1e-9, np.max(dzi))) else: ax1.axes.set_zlim3d(auto=True) ax1.get_autoscalez_on() ax1.w_xaxis.set_ticklabels(row_names, fontsize=14, rotation=45, ha='right', va='top') ax1.w_yaxis.set_ticklabels(column_names, fontsize=14, rotation=-22.5, ha='left', va='center') ax1.set_zlabel('Re[$\\rho$]', fontsize=14) for tick in ax1.zaxis.get_major_ticks(): tick.label.set_fontsize(14) if ax2 is not None: fc2 = generate_facecolors(xpos, ypos, zpos, dx, dy, dzi, color[1]) for idx, cur_zpos in enumerate(zpos): if dzi[idx] > 0: zorder = 2 else: zorder = 0 b2 = ax2.bar3d(xpos[idx], ypos[idx], cur_zpos, dx[idx], dy[idx], dzi[idx], alpha=alpha, zorder=zorder) b2.set_facecolors(fc2[6 * idx:6 * idx + 6]) xlim, ylim = ax2.get_xlim(), ax2.get_ylim() x = [xlim[0], xlim[1], xlim[1], xlim[0]] y = [ylim[0], ylim[0], ylim[1], ylim[1]] z = [0, 0, 0, 0] verts = [list(zip(x, y, z))] pc2 = Poly3DCollection(verts, alpha=0.2, facecolor='k', linewidths=1, zorder=1) if min(dzi) < 0 < max(dzi): ax2.add_collection3d(pc2) ax2.set_xticks(np.arange(0.5, lx + 0.5, 1)) ax2.set_yticks(np.arange(0.5, ly + 0.5, 1)) if min_dzi != max_dzi: eps = 0 ax2.axes.set_zlim3d(np.min(dzi), max(np.max(dzr) + 1e-9, np.max(dzi) + eps)) else: if min_dzi == 0: ax2.set_zticks([0]) eps = 1e-9 ax2.axes.set_zlim3d(np.min(dzi), max(np.max(dzr) + 1e-9, np.max(dzi) + eps)) else: ax2.axes.set_zlim3d(auto=True) ax2.w_xaxis.set_ticklabels(row_names, fontsize=14, rotation=45, ha='right', va='top') ax2.w_yaxis.set_ticklabels(column_names, fontsize=14, rotation=-22.5, ha='left', va='center') ax2.set_zlabel('Im[$\\rho$]', fontsize=14) for tick in ax2.zaxis.get_major_ticks(): tick.label.set_fontsize(14) ax2.get_autoscalez_on() fig.suptitle(title, fontsize=16) if ax_real is None and ax_imag is None: if get_backend() in [ 'module://ipykernel.pylab.backend_inline', 'nbAgg' ]: plt.close(fig) return fig
def plot_state_paulivec(state, title="", figsize=None, color=None, ax=None, *, rho=None): """Plot the paulivec representation of a quantum state. Plot a bargraph of the mixed state rho over the pauli matrices Args: state (Statevector or DensityMatrix or ndarray): an N-qubit quantum state. title (str): a string that represents the plot title figsize (tuple): Figure size in inches. color (list or str): Color of the expectation value bars. ax (matplotlib.axes.Axes): An optional Axes object to be used for the visualization output. If none is specified a new matplotlib Figure will be created and used. Additionally, if specified there will be no returned Figure since it is redundant. Returns: matplotlib.Figure: The matplotlib.Figure of the visualization if the ``ax`` kwarg is not set Raises: ImportError: Requires matplotlib. VisualizationError: if input is not a valid N-qubit state. Example: .. jupyter-execute:: from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector from qiskit.visualization import plot_state_paulivec %matplotlib inline qc = QuantumCircuit(2) qc.h(0) qc.cx(0, 1) state = Statevector.from_instruction(qc) plot_state_paulivec(state, color='midnightblue', title="New PauliVec plot") """ if not HAS_MATPLOTLIB: raise ImportError('Must have Matplotlib installed. To install, run "pip install ' 'matplotlib".') labels, values = _paulivec_data(state) numelem = len(values) if figsize is None: figsize = (7, 5) if color is None: color = "#648fff" ind = np.arange(numelem) # the x locations for the groups width = 0.5 # the width of the bars if ax is None: return_fig = True fig, ax = plt.subplots(figsize=figsize) else: return_fig = False fig = ax.get_figure() ax.grid(zorder=0, linewidth=1, linestyle='--') ax.bar(ind, values, width, color=color, zorder=2) ax.axhline(linewidth=1, color='k') # add some text for labels, title, and axes ticks ax.set_ylabel('Expectation value', fontsize=14) ax.set_xticks(ind) ax.set_yticks([-1, -0.5, 0, 0.5, 1]) ax.set_xticklabels(labels, fontsize=14, rotation=70) ax.set_xlabel('Pauli', fontsize=14) ax.set_ylim([-1, 1]) ax.set_facecolor('#eeeeee') for tick in ax.xaxis.get_major_ticks()+ax.yaxis.get_major_ticks(): tick.label.set_fontsize(14) ax.set_title(title, fontsize=16) if return_fig: if get_backend() in ['module://ipykernel.pylab.backend_inline', 'nbAgg']: plt.close(fig) return fig
# -*- coding: utf-8 -*- ''' ********************************************************** * * SpectraLearnPredict2 - Preprocess data * Perform Machine Learning on Spectroscopy Data. * * Uses: Deep Neural Networks, TensorFlow, SVM, PCA, K-Means * * By: Nicola Ferralis <*****@*****.**> * *********************************************************** ''' import matplotlib if matplotlib.get_backend() == 'TkAgg': matplotlib.use('Agg') import numpy as np import sys, os.path, getopt, glob, csv import random, time, configparser, os from os.path import exists, splitext from os import rename from datetime import datetime, date from .slp_config import * #************************************ ''' Read Learning file '''
def refresh_ptcl(change=None, force=False): """ Refresh the current particle figure Parameters : ------------ change: dictionary Dictionary passed by the widget to a callback functions whenever a change of a widget happens (see docstring of ipywidgets.Widget.observe) This is mainline a place holder ; not used in this function force: bool Whether to force the update """ # Determine whether to do the refresh do_refresh = False if self.avail_species is not None: if force or ptcl_refresh_toggle.value: do_refresh = True # Do the refresh if do_refresh: plt.figure(ptcl_figure_button.value, figsize=figsize) plt.clf() # When working in inline mode, in an ipython notebook, # clear the output (prevents the images from stacking # in the notebook) if 'inline' in matplotlib.get_backend(): clear_output() if ptcl_use_button.value: i_power = ptcl_magnitude_button.value vmin = ptcl_range_button.value[0] * 10**i_power vmax = ptcl_range_button.value[1] * 10**i_power else: vmin = None vmax = None if ptcl_yaxis_button.value == 'None': # 1D histogram self.get_particle(t=self.current_t, output=False, var_list=[ptcl_xaxis_button.value], select=ptcl_select_widget.to_dict(), species=ptcl_species_button.value, plot=True, vmin=vmin, vmax=vmax, cmap=ptcl_color_button.value, nbins=ptcl_bins_button.value) else: # 2D histogram self.get_particle(t=self.current_t, output=False, var_list=[ ptcl_xaxis_button.value, ptcl_yaxis_button.value ], select=ptcl_select_widget.to_dict(), species=ptcl_species_button.value, plot=True, vmin=vmin, vmax=vmax, cmap=ptcl_color_button.value, nbins=ptcl_bins_button.value)
def __enter__(self): if mpl.get_backend() in mpl.rcsetup.interactive_bk: mpl.rcParams['text.latex.preview'] = True
def _save_raw_dialog_box(*, bads, bad_descriptions, annotations, bids_path, verbose): """Display a dialog box asking whether to save the changes.""" # Delay the imports import matplotlib import matplotlib.pyplot as plt from matplotlib.widgets import Button from mne.viz.utils import figure_nobar title = 'Save changes?' message = 'You have modified ' if bads is not None and annotations is None: message += 'the bad channel selection ' figsize = (7.5, 2.5) elif bads is None and annotations is not None: message += 'the bad segments selection ' figsize = (7.5, 2.5) else: message += 'the bad channel and\nannotations selection ' figsize = (8.5, 3) message += (f'of\n' f'{bids_path.basename}.\n\n' f'Would you like to save these changes to the\n' f'BIDS dataset?') icon_fname = str(Path(__file__).parent / 'assets' / 'help-128px.png') icon = plt.imread(icon_fname) fig = figure_nobar(figsize=figsize) fig.canvas.manager.set_window_title('MNE-BIDS Inspector') fig.suptitle(title, y=0.95, fontsize='xx-large', fontweight='bold') gs = fig.add_gridspec(1, 2, width_ratios=(1.5, 5)) # The dialog box tet. ax_msg = fig.add_subplot(gs[0, 1]) ax_msg.text(x=0, y=0.8, s=message, fontsize='large', verticalalignment='top', horizontalalignment='left', multialignment='left') ax_msg.axis('off') # The help icon. ax_icon = fig.add_subplot(gs[0, 0]) ax_icon.imshow(icon) ax_icon.axis('off') # Buttons. ax_save = fig.add_axes([0.6, 0.05, 0.3, 0.1]) ax_dont_save = fig.add_axes([0.1, 0.05, 0.3, 0.1]) save_button = Button(ax=ax_save, label='Save') save_button.label.set_fontsize('medium') save_button.label.set_fontweight('bold') dont_save_button = Button(ax=ax_dont_save, label="Don't save") dont_save_button.label.set_fontsize('medium') dont_save_button.label.set_fontweight('bold') # Store references to keep buttons alive. fig.save_button = save_button fig.dont_save_button = dont_save_button # Define callback functions. def _save_callback(event): plt.close(event.canvas.figure) # Close dialog _global_vars['dialog_fig'] = None if bads is not None: _save_bads(bads=bads, descriptions=bad_descriptions, bids_path=bids_path, verbose=verbose) if annotations is not None: _save_annotations(annotations=annotations, bids_path=bids_path, verbose=verbose) def _dont_save_callback(event): plt.close(event.canvas.figure) # Close dialog _global_vars['dialog_fig'] = None def _keypress_callback(event): if event.key in ['enter', 'return']: _save_callback(event) elif event.key == _global_vars['mne_close_key']: _dont_save_callback(event) # Connect events to callback functions. save_button.on_clicked(_save_callback) dont_save_button.on_clicked(_dont_save_callback) fig.canvas.mpl_connect('close_event', _dont_save_callback) fig.canvas.mpl_connect('key_press_event', _keypress_callback) if matplotlib.get_backend() != 'agg': fig.show() _global_vars['dialog_fig'] = fig
def visualize_solution_scatter(jobs: List['TaskJobs'], title, path: Optional[str] = None, solution_type: Optional[str] = None, logscale=False, ylabel=None, vis_type=VisTypes.Absolute, loc=1, bbox_pos=None, top_margin=0.65, show_legend=True): if solution_type is None: solution_type = _get_dominant_solution_type(jobs) if not ylabel: y_label = _sol_type_to_label[solution_type] for s in tqdm.tqdm(jobs, desc="Calculate lower bounds"): if s.solution is not None: _get_LB(s.solution, solution_type) df = pd.DataFrame([{ "Solver": _get_solver_name(job), "VertAmount": job.solution.graph.vert_amount, "EdgeAmount": job.solution.graph.edge_amount, "Graph_id": job.solution.graph.id, "Runtime": float(job.solution.runtime) if job.prev_job is None else float(job.prev_job.solution.runtime + job.solution.runtime), "MinSum": job.solution.min_sum, "LocalMinSum": job.solution.local_min_sum, "Makespan": job.solution.makespan, "LB": _get_LB(job.solution, solution_type) } for job in tqdm.tqdm(jobs, desc="Collect solution information") if job.solution is not None]) # Then plot the data if vis_type == VisTypes.All: fig, axes = plt.subplots(nrows=2, ncols=2, sharex=True) #fig.suptitle(title) if isinstance(logscale, bool): logscale = [logscale for i in range(4)] if len(logscale) < 4: logscale = logscale + [False for i in range(4 - len(logscale))] label_cols = 3 top_margin = top_margin + 0.2 columns = _plot_data( df, solution_type, "Edge amount", y_label, logscale=logscale[0], vis_type=VisTypes.Absolute, ax=axes[0, 0], ) # show_legend=True) columns = _plot_data( df, solution_type, "Edge amount", y_label, logscale=logscale[1], vis_type=VisTypes.VsBest, ax=axes[0, 1], ) # show_legend=True) columns = _plot_data( df, solution_type, "Edge amount", y_label, logscale=logscale[2], vis_type=VisTypes.VsLB, ax=axes[1, 0], ) # show_legend=True) columns = _plot_data( df, "runtime", "Edge amount", "Runtime", logscale=logscale[3], vis_type=VisTypes.Absolute, ax=axes[1, 1], ) # show_legend=True) fig.set_size_inches(fig.get_size_inches() * 1.5) fig.tight_layout() handles, labels = axes[1, 1].get_legend_handles_labels() fig.legend(handles, labels, loc=loc, bbox_to_anchor=bbox_pos,\ ncol=label_cols) _make_space_above(axes, top_margin) #fig.legend([m_i[1] for m_i in columns], loc=loc, bbox_to_anchor=bbox_pos) elif vis_type == VisTypes.LB_Runtime: fig, axes = plt.subplots(nrows=1, ncols=2, sharex=True) #fig.suptitle(title) if isinstance(logscale, bool): logscale = [logscale for i in range(2)] if len(logscale) < 4: logscale = logscale + [False for i in range(2 - len(logscale))] label_cols = 3 top_margin = top_margin + 0.25 columns = _plot_data( df, solution_type, "Edge amount", y_label, logscale=logscale[0], vis_type=VisTypes.VsLB, ax=axes[0], ) # show_legend=True) columns = _plot_data( df, "runtime", "Edge amount", "Runtime", logscale=logscale[1], vis_type=VisTypes.Absolute, ax=axes[1], ) # show_legend=True) fig.set_size_inches(fig.get_size_inches() * (1.3, 0.9)) fig.tight_layout() handles, labels = axes[1].get_legend_handles_labels() fig.legend(handles, labels, loc=loc, bbox_to_anchor=bbox_pos,\ ncol=label_cols) _make_space_above(axes, top_margin) else: columns = _plot_data(df, solution_type, "Edge amount", y_label, logscale=logscale, vis_type=vis_type, show_legend=True) plt.title(title) if path is None: plt.show() else: if path[-3:] == "ipe": old_backend = matplotlib.get_backend() matplotlib.use('module://backend_ipe') save_format = "ipe" plt.savefig(path, format=save_format) matplotlib.use(old_backend) else: plt.savefig(path)
import wx import matplotlib if matplotlib.get_backend() != 'WXAgg': # this is actually just to check if it's loaded. if it already was loaded # and set to a different backend, then we couldn't change it anyway. matplotlib.use('WXAgg') from matplotlib.figure import Figure as MatplotlibFigure from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as MatplotlibFigureCanvas from matplotlib.backends.backend_wxagg import NavigationToolbar2WxAgg as MatplotlibToolbar class Figure(): """ WxAgg version of the Matplotlib figure. Pass it a wx.Panel as a parent, and then you can access axes, etc. I tried directly inheriting from MatplotlibFigure but I kept getting an error about the axes not being iterable... """ def __init__(self, parent, **kwargs): self.fig = MatplotlibFigure(facecolor=(0.94117, 0.92156, 0.88627), figsize=(4, 4)) self.fig.clf() self.axes = self.fig.add_subplot(111) if 'xlabel' in kwargs.keys(): self.axes.set_xlabel(kwargs['xlabel']) if 'ylabel' in kwargs.keys(): self.axes.set_ylabel(kwargs['ylabel'])
ipythonpath = casa['dirs']['rc'] + '/ipython' try: os.makedirs(ipythonpath, 0755) except: pass if (not os.environ.has_key('IPYTHONDIR')): os.environ['IPYTHONDIR'] = ipythonpath if (not os.path.exists(os.environ['IPYTHONDIR'])): os.makedirs(os.environ['IPYTHONDIR'], 0755) os.environ['__CASARCDIR__'] = casa['dirs']['rc'] # Special case if the back-end is set to MacOSX reset it # to TkAgg as our TablePlot stuff is specific for TkAgg if matplotlib.get_backend() == "MacOSX": matplotlib.use('TkAgg') # Check if the display environment is set if not # switch the backend to Agg only if it's TkAgg if not os.environ.has_key('DISPLAY') and matplotlib.get_backend() == "TkAgg": matplotlib.use('Agg') showconsole = False deploylogger = False thelogfile = 'null' # Task Interface from parameter_check import * # CAS-951: matplotlib unresponsive on some 64bit systems
from pyrates.utility.visualization import plot_timeseries, create_cmap from pyrates.utility.grid_search import grid_search import numpy as np import matplotlib.pyplot as plt from scipy.ndimage.filters import gaussian_filter1d from scipy.signal import correlate import matplotlib as mpl print(mpl.get_backend()) plt.style.reload_library() plt.style.use('ggplot') mpl.rcParams['lines.linewidth'] = 2 mpl.rcParams['axes.titlesize'] = 12 mpl.rcParams['axes.titleweight'] = 'bold' mpl.rcParams['axes.labelsize'] = 12 mpl.rcParams['axes.labelcolor'] = 'black' mpl.rcParams['axes.labelweight'] = 'bold' mpl.rcParams['xtick.labelsize'] = 12 mpl.rcParams['ytick.labelsize'] = 12 mpl.rcParams['xtick.color'] = 'black' mpl.rcParams['ytick.color'] = 'black' mpl.rcParams['legend.fontsize'] = 12 # simulation parameters dt = 1e-3 dts = 1e-1 T = 200.0 # model parameters etas = np.linspace(-200.0, 200.0, num=40) ks = np.asarray([0.2, 0.6, 1.0, 1.4, 1.8])
def _inspect_raw(*, bids_path, l_freq, h_freq, find_flat, show_annotations, verbose=None): """Raw data inspection.""" # Delay the import import matplotlib import matplotlib.pyplot as plt extra_params = dict() if bids_path.extension == '.fif': extra_params['allow_maxshield'] = True raw = read_raw_bids(bids_path, extra_params=extra_params, verbose='error') old_bads = raw.info['bads'].copy() old_annotations = raw.annotations.copy() if find_flat: raw.load_data() # Speeds up processing dramatically flat_annot, flat_chans = annotate_flat(raw=raw, min_duration=0.05, verbose=verbose) new_annot = raw.annotations + flat_annot raw.set_annotations(new_annot) raw.info['bads'] = list(set(raw.info['bads'] + flat_chans)) del new_annot, flat_annot else: flat_chans = [] show_options = bids_path.datatype == 'meg' fig = raw.plot(title=f'{bids_path.root.name}: {bids_path.basename}', highpass=l_freq, lowpass=h_freq, show_options=show_options, block=False, show=False, verbose='warning') # Add our own event handlers so that when the MNE Raw Browser is being # closed, our dialog box will pop up, asking whether to save changes. def _handle_close(event): mne_raw_fig = event.canvas.figure # Bads alterations are only transferred to `inst` once the figure is # closed; Annotation changes are immediately reflected in `inst` new_bads = mne_raw_fig.mne.info['bads'].copy() new_annotations = mne_raw_fig.mne.inst.annotations.copy() if not new_annotations: # Ensure it's not an empty list, but an empty set of Annotations. new_annotations = mne.Annotations( onset=[], duration=[], description=[], orig_time=mne_raw_fig.mne.info['meas_date']) _save_raw_if_changed(old_bads=old_bads, new_bads=new_bads, flat_chans=flat_chans, old_annotations=old_annotations, new_annotations=new_annotations, bids_path=bids_path, verbose=verbose) _global_vars['raw_fig'] = None def _keypress_callback(event): if event.key == _global_vars['mne_close_key']: _handle_close(event) fig.canvas.mpl_connect('close_event', _handle_close) fig.canvas.mpl_connect('key_press_event', _keypress_callback) if not show_annotations: # Remove annotations and kill `_toggle_annotation_fig` method, since # we cannot directly and easily remove the associated `a` keyboard # event callback. fig._clear_annotations() fig._toggle_annotation_fig = lambda: None # Ensure it's not an empty list, but an empty set of Annotations. old_annotations = mne.Annotations(onset=[], duration=[], description=[], orig_time=raw.info['meas_date']) if matplotlib.get_backend() != 'agg': plt.show(block=True) _global_vars['raw_fig'] = fig _global_vars['mne_close_key'] = fig.mne.close_key