def __init__(self, data=None, call_exec=False, loglevel=logging.INFO, interactive=True): """ :param data: Series | Dataframe | [Series] | {str: Series} | None :param call_exec: bool Block by calling app.exec_() and exit on close. Use call_exec=False if running interactively from python prompt. :param loglevel: loglevel the app will log at :param interactive: bool If not run in an interactive prompt, set this to False. Used for configuring inputhook under ipython. """ global QtGui logging.basicConfig( level=loglevel, format="%(asctime)s %(levelname)-8s [%(name)s] : %(message)s" ) logger.debug('Initializing Inspector ...') logger.debug('Using pyqt5: %s', is_pyqt5()) # Make sure that we use any pre-existing QApplication instance if interactive: shell = get_ipython_if_any() if shell: if not shell._inputhook or shell._inputhook.__module__.endswith('.qt'): shell.enable_gui('qt') logger.info("Enabled 'qt' gui in current ipython shell") app = QtWidgets.QApplication.instance() self.app = app or QtWidgets.QApplication(sys.argv) QtGui.qApp = self.app self.model = Model() self.view = View(self.model, data=data, interactive=interactive) if call_exec: sys.exit(self.app.exec_())
def plot_data(x:np.ndarray, y:np.ndarray, xlabel, ylabel): """ Creates a matplotlib plot with all the bells and whistles x - the x axis data y - the y axis data xlabel - a label for the x axis ylabel - a label for the y axis """ from matplotlib.backends.qt_compat import QtWidgets from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas, NavigationToolbar2QT as NavigationToolbar from matplotlib.figure import Figure class ApplicationWindow(QtWidgets.QMainWindow): def __init__(self): super().__init__() self._main = QtWidgets.QWidget() self.setCentralWidget(self._main) layout = QtWidgets.QVBoxLayout(self._main) static_canvas = FigureCanvas(Figure(figsize=(6,6))) layout.addWidget(static_canvas) self.addToolBar(NavigationToolbar(static_canvas, self)) self.static_ax = static_canvas.figure.subplots() self.static_ax.plot(x,y,'.') self.static_ax.set_xlabel(xlabel) self.static_ax.set_ylabel(ylabel) self.static_ax.set_title(ylabel + ' as a function of ' + xlabel) self.static_canvas.figure.savefig('/media/usb1/DYNODATA/drive/plot'+str(len(os.listdir('/media/usb1/DYNODATA/drive/test')))+'.csv') qapp = QtWidgets.QApplication(sys.argv) app = ApplicationWindow() app.show() qapp.exec_()
def _create_qApp(): """ Only one qApp can exist at a time, so check before creating one. """ global qApp if qApp is None: app = QtWidgets.QApplication.instance() if app is None: # check for DISPLAY env variable on X11 build of Qt if is_pyqt5(): try: from PyQt5 import QtX11Extras is_x11_build = True except ImportError: is_x11_build = False else: is_x11_build = hasattr(QtGui, "QX11Info") if is_x11_build: display = os.environ.get('DISPLAY') if display is None or not re.search(r':\d', display): raise RuntimeError('Invalid DISPLAY variable') qApp = QtWidgets.QApplication([b"matplotlib"]) qApp.lastWindowClosed.connect(qApp.quit) else: qApp = app if is_pyqt5(): try: qApp.setAttribute(QtCore.Qt.AA_UseHighDpiPixmaps) qApp.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling) except AttributeError: pass
def main(): app = QtWidgets.QApplication(sys.argv) if len(sys.argv) != 2: print(sys.argv) print('Please supply the fits file for the data') sys.exit() else: AppWin = ApplicationWindow(sys.argv[1]) AppWin.show() sys.exit(app.exec_())
def runMe(cmd_args): # Check whether there is already a running QApplication (e.g., if running # from an IDE). qapp = QtWidgets.QApplication.instance() if not qapp: qapp = QtWidgets.QApplication(sys.argv) app = MainApp('Iseult', cmd_args) app.show() app.activateWindow() app.raise_() qapp.exec_()
def test_form_widget_get_with_datetime_and_date_fields(): if not QtWidgets.QApplication.instance(): QtWidgets.QApplication() form = [("Datetime field", datetime(year=2021, month=3, day=11)), ("Date field", date(year=2021, month=3, day=11))] widget = _formlayout.FormWidget(form) widget.setup() values = widget.get() assert values == [ datetime(year=2021, month=3, day=11), date(year=2021, month=3, day=11) ]
def visualization(model, snapshot, tub): Model = load_model_class(model) model = Model() model.load(os.path.expanduser(snapshot)) reader = ExtendedRecordsReader(tub, model) qapp = QtWidgets.QApplication([]) app = ApplicationWindow(reader) app.show() qapp.exec_() print("exited")
def xncview(dataset): """ Starts a QT window to display the data Args: dataset: xarray.Dataset """ QApp = QW.QApplication.instance() if QApp is None: QApp = QW.QApplication(sys.argv) widget = Widget(dataset) widget.resize(1200, 800) widget.show() return QApp.exec_()
def __init__(self, plot_callback=None, call_exec=False, interactive=True): if interactive: shell = get_ipython_if_any() if shell and not shell._inputhook.__module__.endswith('.qt'): shell.enable_gui('qt') logger.info("Enabled 'qt' gui in current ipython shell") maybe_existing_app = QtWidgets.QApplication.instance() self.app = maybe_existing_app or QtWidgets.QApplication(sys.argv) from matplotlib.backends.qt_compat import QtGui QtGui.qApp = self.app if plot_callback is None: plot_callback = default_sample_plot self.builder = StyleBuilderMainWidget(plot_callback) self.builder.build_tree() if call_exec: sys.exit(self.app.exec_())
def launch(result_images, source): """ Launch the GUI. """ entries = find_failing_tests(result_images, source) if len(entries) == 0: print("No failed tests") sys.exit(0) app = QtWidgets.QApplication(sys.argv) dialog = Dialog(entries) dialog.show() filter = EventFilter(dialog) app.installEventFilter(filter) sys.exit(app.exec_())
def preview(data_object): """Quick preview od the dataset.""" axes = [] data = deepcopy(data_object) # for i, dim in enumerate(data.dimensions): # if hasattr(dim, "complex_fft"): # if dim.complex_fft: # npts = dim.count # if npts % 2 == 0: # temp = npts * dim.increment / 2.0 # else: # temp = (npts - 1) * dim.increment / 2.0 # dim.coordinates_offset = dim.coordinates_offset - temp # axes.append(-i - 1) # dim.complex_fft = False for var in data.dependent_variables: var.components = fftshift(var.components, axes=axes) # print(matplotlib.get_backend()) if matplotlib.get_backend() in ["Qt5Agg", "Qt4Agg"]: x = data.dimensions number_of_independents = len(x) if number_of_independents == 0: print("Preview of zero dimensional datasets is not implemented.") return if number_of_independents > 2: print( "Preview of three or higher dimensional datasets " "is not implemented." ) return if np.any([x[i].type == "labeled" for i in range(len(x))]): print("Preview of labeled plots is not implemented.") return qapp = QtWidgets.QApplication(sys.argv) app = ApplicationWindow(data) app.show() sys.exit(qapp.exec_()) else: _preview(data)
def fedit(data, title="", comment="", icon=None, parent=None, apply=None): """ Create form dialog and return result (if Cancel button is pressed, return None) data: datalist, datagroup title: str comment: str icon: QIcon instance parent: parent QWidget apply: apply callback (function) datalist: list/tuple of (field_name, field_value) datagroup: list/tuple of (datalist *or* datagroup, title, comment) -> one field for each member of a datalist -> one tab for each member of a top-level datagroup -> one page (of a multipage widget, each page can be selected with a combo box) for each member of a datagroup inside a datagroup Supported types for field_value: - int, float, str, unicode, bool - colors: in Qt-compatible text form, i.e. in hex format or name (red, ...) (automatically detected from a string) - list/tuple: * the first element will be the selected index (or value) * the other elements can be couples (key, value) or only values """ # Create a QApplication instance if no instance currently exists # (e.g., if the module is used directly from the interpreter) if QtWidgets.QApplication.startingUp(): _app = QtWidgets.QApplication([]) dialog = FormDialog(data, title, comment, icon, parent, apply) if parent is not None: if hasattr(parent, "_fedit_dialog"): parent._fedit_dialog.close() parent._fedit_dialog = dialog dialog.show()
def __init__(self): self.qapp = QtWidgets.QApplication(sys.argv) super(TimePlot, self).__init__() self._main = QtWidgets.QWidget() self.setCentralWidget(self._main) self.layout = QtWidgets.QGridLayout(self._main) # Empty objects that will be used during visualization. self.fig = None self.frames = None # Slider stuff hbox_timeline = QtWidgets.QHBoxLayout() self.slider = QtWidgets.QSlider(QtCore.Qt.Horizontal) self.slider.setMinimum(0) self.slider.valueChanged.connect(self.slider_valuechanged) hbox_timeline.addWidget(self.slider) self.layout.addLayout(hbox_timeline, 1, 0) # Bottom buttons hbox_buttons = QtWidgets.QHBoxLayout() hbox_buttons.addStretch(1) # Button for saving movies. save_movie_btn = QtWidgets.QPushButton( "&Save as movie") # Shortcut is Alt+S save_movie_btn.clicked.connect(self._save_movie_clicked) # Button for next episode. next_btn = QtWidgets.QPushButton("&Next episode") # Shortcut is Alt+N next_btn.clicked.connect(self._next_clicked) # Quit button. quit_btn = QtWidgets.QPushButton("&Quit") # Shortcut is Alt+Q quit_btn.clicked.connect(self.closeEvent) # Add buttons to widget. hbox_buttons.addWidget(save_movie_btn) hbox_buttons.addWidget(next_btn) hbox_buttons.addWidget(quit_btn) self.layout.addLayout(hbox_buttons, 2, 0) self.is_closed = False self.is_playing = False
def main(): app = QtWidgets.QApplication(sys.argv) if len(sys.argv) < 2: print(sys.argv) print('Please supply the python script that defines the model') sys.exit() elif len(sys.argv) == 2: if sys.argv[1].endswith('.py'): sys.argv[1] = sys.argv[1][:-3] AppWin = ApplicationWindow(sys.argv[1]) AppWin.show() sys.exit(app.exec_()) elif len(sys.argv) == 3: if sys.argv[1].endswith('.py'): sys.argv[1] = sys.argv[1][:-3] AppWin = ApplicationWindow(sys.argv[1], sys.argv[2]) AppWin.show() sys.exit(app.exec_()) else: print(sys.argv) print('Too many arguments supplied to the funcion.') sys.exit()
self._static_ax.plot(t, np.tan(t), ".") self._dynamic_ax = dynamic_canvas.figure.subplots() self._timer = dynamic_canvas.new_timer(50) self._timer.add_callback(self._update_canvas) self._timer.start() def _update_canvas(self): self._dynamic_ax.clear() t = np.linspace(0, 10, 101) # Use fixed vertical limits to prevent autoscaling changing the scale # of the axis. self._dynamic_ax.set_ylim(-1.1, 1.1) # Shift the sinusoid as a function of time. self._dynamic_ax.plot(t, np.sin(t + time.time())) self._dynamic_ax.figure.canvas.draw() if __name__ == "__main__": # Check whether there is already a running QApplication (e.g., if running # from an IDE). qapp = QtWidgets.QApplication.instance() if not qapp: qapp = QtWidgets.QApplication(sys.argv) app = ApplicationWindow() app.show() app.activateWindow() app.raise_() qapp.exec_()
from pygerm import TRIGGER_SETUP_SEQ, START_DAQ, STOP_DAQ import time as tm import matplotlib matplotlib.use('Qt5Agg') import matplotlib.pyplot as plt from matplotlib.backends.qt_compat import QtWidgets, QtCore plt.ion() # Create an QApplication object. a = QtWidgets.QApplication.instance() if a is None: a = QtWidgets.QApplication(["MARS DAQ"]) a.lastWindowClosed.connect(a.quit) # The QWidget widget is the base class of all user interface objects in PyQt4. w = QtWidgets.QWidget() # Set window size. w.resize(320, 140) # Set window title w.setWindowTitle("MARS DAQ!") # Add a button btn_q = QtWidgets.QPushButton('Quit!', w) btn_trig = QtWidgets.QPushButton('DAQ Trigger', w)
def show(time, data, com, com_dot, com_ddot, com_i, grf, angles, stick): qapp = QtWidgets.QApplication(sys.argv) app = QtWidgets.QMainWindow() app.setWindowTitle("Analyse biomécanique de Kinovea") _main = QtWidgets.QWidget() app.setCentralWidget(_main) main_layout = QtWidgets.QHBoxLayout(_main) # Body position column body_position_layout = QtWidgets.QVBoxLayout() main_layout.addLayout(body_position_layout) # Show model body_position_canvas = FigureCanvas(Figure(figsize=(5, 3))) body_position_layout.addWidget(body_position_canvas) body_position_ax = body_position_canvas.figure.subplots() time_idx = 0 body_position_ax.set_ylabel("Axe vertical (m)") body_position_ax.set_xlabel("Axe frontal (m)") body_position_text = body_position_ax.text( 0.5, 0.99, "", fontsize=12, horizontalalignment='center', verticalalignment='top', transform=body_position_ax.transAxes ) kino_n_image = 5 kino_pre_plot = [] kino_post_plot = [] kino_colors = np.linspace(0.88, 0, kino_n_image) for i in range(kino_n_image): i2 = kino_n_image - 1 - i kino_pre_plot.append( body_position_ax.plot(np.nan, np.nan, color=[kino_colors[i2], kino_colors[i2], kino_colors[i2]]) ) kino_post_plot.append( body_position_ax.plot(np.nan, np.nan, color=[kino_colors[i2], kino_colors[i2], kino_colors[i2]]) ) stick_plot = body_position_ax.plot(np.nan, np.nan, 'r') comi_plot = body_position_ax.plot(np.nan, np.nan, 'k.') com_plot = body_position_ax.plot(np.nan, np.nan, 'k.', markersize=20) def move_stick_figure(time_idx): body_position_ax.set_title(f"Position du corps à l'instant {time[time_idx]:.2f} s") body_position_text.set_text(f"CoM = [{str(np.round(com[0, 0, time_idx], 2))}; {str(np.round(com[1, 0, time_idx], 2))}]") for i in range(kino_n_image): if time_idx - i - 1 >= 0 and kino_pre_check.isChecked(): kino_pre_plot[i][0].set_data(data[0, stick, time_idx - i - 1], data[1, stick, time_idx - i - 1]) else: kino_pre_plot[i][0].set_data(np.nan, np.nan) if time_idx + i + 1 < data.shape[2] and kino_post_check.isChecked(): kino_post_plot[i][0].set_data(data[0, stick, time_idx + i + 1], data[1, stick, time_idx + i + 1]) else: kino_post_plot[i][0].set_data(np.nan, np.nan) stick_plot[0].set_data(data[0, stick, time_idx], data[1, stick, time_idx]) comi_plot[0].set_data(com_i[0, :, time_idx], com_i[1, :, time_idx]) com_plot[0].set_data(com[0, 0, time_idx], com[1, 0, time_idx]) # Force axis equal with min and max data body_position_ax.plot( [np.min(data[0, :, :]), np.max(data[0, :, :])], [np.min(data[1, :, :]) - (np.max(data[1, :, :]) - np.min(data[1, :, :]))*0.1 , np.max(data[1, :, :]) + (np.max(data[1, :, :]) - np.min(data[1, :, :]))*0.1 ], 'w.' ) body_position_ax.axis('equal') time_slider = QtWidgets.QSlider(QtCore.Qt.Horizontal) body_position_layout.addWidget(time_slider) kinogram_layout = QtWidgets.QHBoxLayout() body_position_layout.addLayout(kinogram_layout) kino_pre_check = QtWidgets.QCheckBox() kino_pre_check.setText("Kinogramme pre") kinogram_layout.addWidget(kino_pre_check) kino_post_check = QtWidgets.QCheckBox() kino_post_check.setText("Kinogramme post") kinogram_layout.addWidget(kino_post_check) # Trajectory column trajectory_canvas = FigureCanvas(Figure(figsize=(5, 3))) main_layout.addWidget(trajectory_canvas) buffer = (time[-1]-time[0])*0.005 xlim = (time[0]-buffer, time[-1]+buffer) ax_height = trajectory_canvas.figure.add_subplot(411) ax_height.set_title("Hauteur du CoM") ax_height.set_ylabel("Hauteur (m)") ax_height.tick_params(axis='x', which='both', bottom=False, top=False, labelbottom=False) ax_height.plot(time, com[1, 0, :]) ylim = ax_height.get_ylim() height_vbar = ax_height.plot((np.nan, np.nan), ylim, 'r') ax_height.set_xlim(xlim) ax_height.set_ylim(ylim) ax_velocity = trajectory_canvas.figure.add_subplot(412) ax_velocity.set_title("Vitesse verticale") ax_velocity.set_ylabel("Vitesse (m/s)") ax_velocity.tick_params(axis='x', which='both', bottom=False, top=False, labelbottom=False) ax_velocity.plot(time, com_dot[1, 0, :]) ylim = ax_velocity.get_ylim() velocity_vbar = ax_velocity.plot((np.nan, np.nan), ylim, 'r') ax_velocity.set_xlim(xlim) ax_velocity.set_ylim(ylim) ax_acceleration = trajectory_canvas.figure.add_subplot(413) ax_acceleration.set_title("Accélération verticale") ax_acceleration.set_ylabel("Accélération (m/s²)") ax_acceleration.tick_params(axis='x', which='both', bottom=False, top=False, labelbottom=False) ax_acceleration.plot(time, com_ddot[1, 0, :]) ylim = ax_acceleration.get_ylim() acceleration_vbar = ax_acceleration.plot((np.nan, np.nan), ylim, 'r') ax_acceleration.set_xlim(xlim) ax_acceleration.set_ylim(ylim) ax_grf = trajectory_canvas.figure.add_subplot(414) ax_grf.set_title("GRF") ax_grf.set_ylabel("GRF (N)") ax_grf.set_xlabel("Temps (s)") ax_grf.plot(time, grf[1, 0, :]) ylim = ax_grf.get_ylim() grf_vbar = ax_grf.plot((np.nan, np.nan), ylim, 'r') ax_grf.set_xlim(xlim) ax_grf.set_ylim(ylim) trajectory_canvas.figure.tight_layout(h_pad=-0.5, w_pad=-6) # Angles column angles_canvas = FigureCanvas(Figure(figsize=(5, 3))) main_layout.addWidget(angles_canvas) ax_angles = angles_canvas.figure.subplots() ax_angles.set_title("Angles articulaire au cours du temps") ax_angles.set_ylabel("Angle (°)") ax_angles.set_xlabel("Temps (s)") for joint in angles.values(): ax_angles.plot(time, KinoveaReader.to_degree(joint)) ylim = ax_angles.get_ylim() angles_vbar = ax_angles.plot((np.nan, np.nan), ylim, 'r') ax_angles.set_xlim(xlim) ax_angles.set_ylim(ylim) ax_angles.legend(angles.keys()) def change_time(): time_idx = time_slider.value() move_stick_figure(time_idx) body_position_canvas.draw() height_vbar[0].set_xdata([time[time_idx], time[time_idx]]) velocity_vbar[0].set_xdata([time[time_idx], time[time_idx]]) acceleration_vbar[0].set_xdata([time[time_idx], time[time_idx]]) grf_vbar[0].set_xdata([time[time_idx], time[time_idx]]) trajectory_canvas.draw() angles_vbar[0].set_xdata([time[time_idx], time[time_idx]]) angles_canvas.draw() time_slider.setMinimum(0) time_slider.setMaximum(time.shape[0] - 1) time_slider.setPageStep(1) time_slider.setValue(0) time_slider.valueChanged.connect(change_time) body_position_canvas.mpl_connect(body_position_canvas.resize_event, change_time) kino_pre_check.stateChanged.connect(change_time) kino_post_check.stateChanged.connect(change_time) # app.showMaximized() change_time() app.show() qapp.exec_()
self.editing = False self.lower_double.hide() self.lower_single.hide() self.all_plots.redraw() def update_selection(self): if self.selected_ipo == self.all_plots.ipo_y_phase: self.select_pv(self.selected_ipo, self.selected_y) else: self.select(self.selected_ipo, self.selected_y) def keyPressEvent(self, e): key = e.key() if key == Qt.Key_Escape: self.close() elif key == Qt.Key_F: self.selected_y += 1 self.update_selection() elif key == Qt.Key_S: self.selected_y -= 1 self.update_selection() if __name__ == "__main__": # if we don't pass the style, we'll get some warnings # https://github.com/therecipe/qt/issues/306 qapp = QtWidgets.QApplication(['main.py', '--style', 'Fusion']) app = ApplicationWindow() app.show() qapp.exec_()
@QtCore.pyqtSlot() def toggle_pulser(self): req = wib.Pulser() if self.pulser_button.text() == "Enable Pulser": req.start = True self.pulser_button.setText('Disable Pulser') print("Starting pulser") else: req.start = False self.pulser_button.setText('Enable Pulser') print("Stopping pulser") rep = wib.Status() self.send_command(req,rep); if __name__ == "__main__": parser = argparse.ArgumentParser(description='Visually display data from a WIB') parser.add_argument('--wib_server','-w',default='127.0.0.1',help='IP of wib_server to connect to [127.0.0.1]') parser.add_argument('--config','-C',default='default.json',help='WIB configuration to load [default.json]') parser.add_argument('--rows','-r',default=1,type=int,help='Rows of plots [1]') parser.add_argument('--cols','-c',default=1,type=int,help='Columns of plots [1]') parser.add_argument('--layout','-l',default=None,help='Load a saved layout') args = parser.parse_args() qapp = QtWidgets.QApplication([]) qapp.setApplicationName('WIB Scope (%s)'%args.wib_server) app = EvDisp(**vars(args)) app.show() qapp.exec_()
def main(): e = 2.718281828459045235360287471352662497757247093699959574966967627724076630353 app = QtWidgets.QApplication(sys.argv) application = ApplicationWindow() application.show() sys.exit(app.exec_())
def main(): app = QtWidgets.QApplication(sys.argv) w = Program() w.show() sys.exit(app.exec_())
def gui(): qapp = QtWidgets.QApplication(sys.argv) app = ApplicationWindow() app.show() qapp.exec()
def main(): app = QtWidgets.QApplication(sys.argv) form = Form() form.show() app.exec_()
def default_during_task(blocking_event): """ The default setting for the RunEngine's during_task parameter. This makes it possible for plots that use matplotlib's Qt backend to update live during data acquisition. It solves the problem that Qt must be run from the main thread. If matplotlib and a known Qt binding are already imported, run the matplotlib qApp until the task completes. If not, there is no need to handle qApp: just wait on the task. """ global _qapp if 'matplotlib' not in sys.modules: # We are not using matplotlib + Qt. Just wait on the Event. blocking_event.wait() # Figure out if we are using matplotlib with which backend # without importing anything that is not already imported. else: import matplotlib backend = matplotlib.get_backend().lower() # if with a Qt backend, do the scary thing if 'qt' in backend: from matplotlib.backends.qt_compat import QtCore, QtWidgets app = QtWidgets.QApplication.instance() if app is None: _qapp = app = QtWidgets.QApplication([b'bluesky']) assert app is not None event_loop = QtCore.QEventLoop() def start_killer_thread(): def exit_loop(): blocking_event.wait() # If the above wait ends quickly, we need to avoid the race # condition where this thread might try to exit the qApp # before it even starts. Therefore, we use QTimer, below, # which will not start running until the qApp event loop is # running. event_loop.exit() threading.Thread(target=exit_loop).start() # https://www.riverbankcomputing.com/pipermail/pyqt/2015-March/035674.html # adapted from code at # https://bitbucket.org/tortoisehg/thg/commits/550e1df5fbad if os.name == 'posix' and hasattr(signal, 'set_wakeup_fd'): # Wake up Python interpreter via pipe so that SIGINT # can be handled immediately. # (http://qt-project.org/doc/qt-4.8/unix-signals.html) # Updated docs: # https://doc.qt.io/qt-5/unix-signals.html import fcntl rfd, wfd = os.pipe() for fd in (rfd, wfd): flags = fcntl.fcntl(fd, fcntl.F_GETFL) fcntl.fcntl(fd, fcntl.F_SETFL, flags | os.O_NONBLOCK) wakeupsn = QtCore.QSocketNotifier(rfd, QtCore.QSocketNotifier.Read) origwakeupfd = signal.set_wakeup_fd(wfd) def cleanup(): wakeupsn.setEnabled(False) rfd = wakeupsn.socket() wfd = signal.set_wakeup_fd(origwakeupfd) os.close(int(rfd)) os.close(wfd) def handleWakeup(inp): # here Python signal handler will be invoked # this book-keeping is to drain the pipe wakeupsn.setEnabled(False) rfd = wakeupsn.socket() try: os.read(int(rfd), 4096) except OSError as inst: print('failed to read wakeup fd: %s\n' % inst) wakeupsn.setEnabled(True) wakeupsn.activated.connect(handleWakeup) else: # On Windows, non-blocking anonymous pipe or socket is # not available. def null(): ... # we need to 'kick' the python interpreter so it sees # system signals # https://stackoverflow.com/a/4939113/380231 kick_timer = QtCore.QTimer() kick_timer.timeout.connect(null) kick_timer.start(50) cleanup = kick_timer.stop # we also need to make sure that the qApp never sees # exceptions raised by python inside of a c++ callback (as # it will segfault its self because due to the way the # code is called there is no clear way to propgate that # back to the python code. vals = (None, None, None) old_sys_handler = sys.excepthook def my_exception_hook(exctype, value, traceback): nonlocal vals vals = (exctype, value, traceback) event_loop.exit() old_sys_handler(exctype, value, traceback) # this kill the Qt event loop when the plan is finished killer_timer = QtCore.QTimer() killer_timer.setSingleShot(True) killer_timer.timeout.connect(start_killer_thread) killer_timer.start(0) try: sys.excepthook = my_exception_hook event_loop.exec_() # make sure any pending signals are processed event_loop.processEvents() if vals[1] is not None: raise vals[1] finally: try: cleanup() finally: sys.excepthook = old_sys_handler elif 'ipympl' in backend or 'nbagg' in backend: Gcf = matplotlib._pylab_helpers.Gcf while True: done = blocking_event.wait(.1) for f_mgr in Gcf.get_all_fig_managers(): if f_mgr.canvas.figure.stale: f_mgr.canvas.draw() if done: return else: # We are not using matplotlib + Qt. Just wait on the Event. blocking_event.wait()
def main(): global app app = QtWidgets.QApplication(sys.argv) gui = Window() sys.exit(app.exec_())
def main(): app = QtWidgets.QApplication(sys.argv) application = ApplicationWindow() application.show() app.exec_()
# non-ipython envs with suppress(ImportError): from IPython import get_ipython with suppress(AttributeError, NameError): # List available APIs get_ipython().run_line_magic("matplotlib", "-l") get_ipython().run_line_magic("matplotlib", "qt5") print(plt.get_backend()) #%% Matplotlib adjustments # Adjust matplotlib qt5 backend for high DPI monitors if plt.get_backend() == "Qt5Agg": from matplotlib.backends.qt_compat import QtWidgets # pylint: disable=C0412 from sys import argv qApp = QtWidgets.QApplication(argv) plt.matplotlib.rcParams["figure.dpi"] = qApp.desktop().physicalDpiX() # Set LaTeX compatibility settings # matplotlib.use("pgf") matplotlib.rcParams.update({ "pgf.texsystem": "pdflatex", "font.family": "sans-serif", "text.usetex": True, "pgf.rcfonts": False, }) # plt.rcParams["figure.autolayout"] = True # Adjust figure default size plt.rcParams["figure.figsize"] = (6, 4) # Default fig size (w, h))
def show_GUI(pupil, luminance_range): qapp = QtWidgets.QApplication(sys.argv) app = ApplicationWindow(pupil, luminance_range) app.show() qapp.exec_()