def __init__(self, hostname, port=9998, interval=.1, alarm=None): # run the base class constructor super().__init__() # initialize the connection self.hostname = hostname self.port = port self.initialize() # set some properties self.setWindowTitle(hostname) self.hasData = False self.alarm = alarm # self.waiting_for_frame = False # self.latest_request = time.time() # a periodic timer triggers the update self.timer = qt.QTimer(self) self.timer.setInterval(interval * 1000.0) self.timer.timeout.connect(self._update) self.timer.start() # a periodic timer triggers the update self.timer = qt.QTimer(self) self.timer.setInterval(interval * 1000.0) self.timer.timeout.connect(self._update) self.timer.start()
def __init__(self, hostname, port=9998, interval=.1, alarm=None): # run the base class constructor super().__init__() # initialize the connection self.hostname = hostname self.port = port self.initialize() # set some properties self.setWindowTitle(hostname) self.setKeepDataAspectRatio(True) self.setColormap(normalization='log') self.setYAxisInverted(True) self.hasImage = False self.alarm = alarm self.waiting_for_frame = False self.latest_request = time.time() # a periodic timer triggers the update self.timer = qt.QTimer(self) self.timer.setInterval(interval * 1000.0) self.timer.timeout.connect(self._update) self.timer.start() # Display mouseover position info posInfo = [ ('X', lambda x, y: int(x)), ('Y', lambda x, y: int(y)), ('Data', self._getActiveImageValue)] self._positionWidget = tools.PositionInfo(plot=self, converters=posInfo) self.statusBar().addWidget(self._positionWidget)
def __init__(self, parent=None, timeout=14): super(TimerMessageBox, self).__init__(parent) self.setWindowTitle("Dark Current") self.time_to_wait = timeout self.setText( "Measuring dark current (Done in {0} secondes.)".format(timeout)) self.setStandardButtons(qt.QMessageBox.NoButton) self.timer = qt.QTimer(self) self.timer.setInterval(1000) self.timer.timeout.connect(self.changeContent) self.timer.start()
def mainQtApp(options): """Part of the main application depending on Qt""" try: # it should be loaded before h5py import hdf5plugin # noqa except ImportError: _logger.debug("Backtrace", exc_info=True) import h5py import silx import silx.utils.files from silx.gui import qt # Make sure matplotlib is configured # Needed for Debian 8: compatibility between Qt4/Qt5 and old matplotlib from silx.gui.plot import matplotlib _logger.info('Starting application') app = qt.QApplication([]) qt.QLocale.setDefault(qt.QLocale.c()) def sigintHandler(*args): """Handler for the SIGINT signal.""" qt.QApplication.quit() signal.signal(signal.SIGINT, sigintHandler) sys.excepthook = qt.exceptionHandler timer = qt.QTimer() timer.start(500) # Application have to wake up Python interpreter, else SIGINT is not # catched timer.timeout.connect(lambda: None) from .window import RixsAppWindow as MainWindow window = MainWindow(with_ipykernel=True) window.setAttribute(qt.Qt.WA_DeleteOnClose, True) window.show() _logger.info('Finished initialization') # Very important, IPython-specific step: this gets GUI event loop # integration going, and it replaces calling app.exec_() _logger.info('Starting the IPython kernel') window._ipykernel.kernel.start() result = app.exec_() # remove ending warnings relative to QTimer app.deleteLater() return result
def __init__(self, parent, plot3d=None): super(RotateViewport, self).__init__(parent, plot3d) self._previousTime = None self._timer = qt.QTimer(self) self._timer.setInterval(self._TIMEOUT_MS) # 20fps self._timer.timeout.connect(self._rotate) self.setIcon(getQIcon('cube-rotate')) self.setText('Rotate scene') self.setToolTip('Rotate the 3D scene around the vertical axis') self.setCheckable(True) self.triggered[bool].connect(self._triggered)
def __mergeStart(self): self.__bn_box.rejected.disconnect(self.reject) self.__bn_box.rejected.connect(self.__onAbort) self.__bn_box.button(Qt.QDialogButtonBox.Ok).setEnabled(False) self.__bn_box.button(Qt.QDialogButtonBox.Cancel).setText('Abort') self.__qtimer = Qt.QTimer() self.__qtimer.timeout.connect(self.__onProgress) self.__merger.merge(overwrite=True, blocking=False, callback=self.__sigMergeDone.emit) self.__onProgress() self.__qtimer.start(1000) self.__time = time.time()
def __init__(self, pv, scaler_pv=None, moving_pv=None, moving_val=0, precision=3, limit_hi=9, *args, **kwargs): super().__init__(*args, **kwargs) if scaler_pv: self.count_mode = epics.PV(scaler_pv + '.CONT') self.count_time = epics.PV(scaler_pv + '.TP') self.auto_count_time = epics.PV(scaler_pv + '.TP1') self.setMinimumSize(qt.QSize(120, 30)) self.setMaximumSize(qt.QSize(120, 30)) self.precision = precision self.setFrameShape(qt.QFrame.Panel) self.setFrameShadow(qt.QFrame.Sunken) self.setAlignment(qt.Qt.AlignCenter) self.setText("not connected") self.formatStr = "{:." + str(self.precision) + "f}" self.moving_val = moving_val self.pv = epics.PV(pv, auto_monitor=True) self.pv.add_callback(self.update_value) if moving_pv is not None: self.moving_pv = epics.PV(moving_pv, auto_monitor=True) self.moving_pv.add_callback(self.update_color) self.limit_hi = limit_hi self._dummyIndex = 0 self.notifyTimer = qt.QTimer() self.notifyTimer.timeout.connect(self._notifyColor) self.notifyTimer.start(1000)
def __init__(self, converter, parent=None, **kwargs): """ Simple widget displaying a progress bar and a info label during the conversion process. :param converter: :param parent: :param kwargs: """ super(_ConversionProcessDialog, self).__init__(parent) layout = Qt.QVBoxLayout(self) progress_bar = Qt.QProgressBar() layout.addWidget(progress_bar) status_lab = Qt.QLabel('<font color="blue">Conversion ' 'in progress</font>') status_lab.setFrameStyle(Qt.QFrame.Panel | Qt.QFrame.Sunken) layout.addWidget(status_lab) bn_box = Qt.QDialogButtonBox(Qt.QDialogButtonBox.Abort) layout.addWidget(bn_box) bn_box.accepted.connect(self.accept) bn_box.rejected.connect(self.__onAbort) self.__sigConvertDone.connect(self.__convertDone) self.__bn_box = bn_box self.__progress_bar = progress_bar self.__status_lab = status_lab self.__converter = converter self.__aborted = False self.__qtimer = Qt.QTimer() self.__qtimer.timeout.connect(self.__onProgress) converter.convert(blocking=False, overwrite=True, callback=self.__sigConvertDone.emit, **kwargs) self.__qtimer.start(1000)
def __init__(self, signal, delay=0.3, rateLimit=0, slot=None): """Initialization arguments: signal - a bound Signal or pyqtSignal instance delay - Time (in seconds) to wait for signals to stop before emitting (default 0.3s) slot - Optional function to connect sigDelayed to. rateLimit - (signals/sec) if greater than 0, this allows signals to stream out at a steady rate while they are being received. """ qt.QObject.__init__(self) signal.connect(self.signalReceived) self.signal = signal self.delay = delay self.rateLimit = rateLimit self.args = None self.timer = qt.QTimer() self.timer.timeout.connect(self.flush) self.blockSignal = False self.slot = weakref.ref(slot) self.lastFlushTime = None if slot is not None: self.sigDelayed.connect(slot)
def __init__(self, pv, *args, **kwargs): super(EpicsStringLabel, self).__init__(*args, **kwargs) self._dummyIndex = 0 self.setMinimumSize(qt.QSize(130, 30)) self.setMaximumSize(qt.QSize(130, 30)) self.setFrameShape(qt.QFrame.Panel) self.setFrameShadow(qt.QFrame.Sunken) self.setAlignment(qt.Qt.AlignCenter) self.setText("not connected") self.pv = epics.PV(pv, auto_monitor=True) self.pv.add_callback(self.update_value) self.notifyTimer = qt.QTimer() self.notifyTimer.timeout.connect(self._notifyColor) self.notifyTimer.start(1000) # Set initial value from pv if self.pv.connected: if self.pv.get(): _submit(self.setText, str("On"))
def __slotRunClicked(self): # TODO : put some safeguards self.__lock(True) self.__progBar.setValue(0) fitType = FitWidget.FitTypes[self.__fitTypeCb.currentText()] if self.__roiWidget.isActive(): x0, x1 = self.__roiWidget.xSlider().getSliderIndices() y0, y1 = self.__roiWidget.ySlider().getSliderIndices() z0, z1 = self.__roiWidget.zSlider().getSliderIndices() roiIndices = [[x0, x1 + 1], [y0, y1 + 1], [z0, z1 + 1]] else: roiIndices = None self.__fitter = fitter = PeakFitter(self.__qspaceH5.filename, fit_type=fitType, roi_indices=roiIndices, n_peaks=self.__nPeaks) self.__statusLabel.setText('Running...') self.__progTimer = timer = Qt.QTimer() timer.setSingleShot(True) timer.timeout.connect(self.__slotProgTimer) try: self.sigProcessStarted.emit() fitter.peak_fit(blocking=False, callback=self.__sigFitDone.emit) timer.start(self.__progressDelay) except Exception as ex: # TODO : popup self.__statusLabel.setText('ERROR') print('ERROR : {0}.'.format(ex)) self.__lock(False) self.sigProcessDone.emit(None)
def main(argv): """ Main function to launch the viewer as an application :param argv: Command line arguments :returns: exit status """ parser = createParser() options = parser.parse_args(argv[1:]) if options.debug: logging.root.setLevel(logging.DEBUG) # # Import most of the things here to be sure to use the right logging level # try: # it should be loaded before h5py import hdf5plugin # noqa except ImportError: _logger.debug("Backtrace", exc_info=True) try: import h5py except ImportError: _logger.debug("Backtrace", exc_info=True) h5py = None if h5py is None: message = "Module 'h5py' is not installed but is mandatory."\ + " You can install it using \"pip install h5py\"." _logger.error(message) return -1 # # Run the application # app = qt.QApplication([]) qt.QLocale.setDefault(qt.QLocale.c()) signal.signal(signal.SIGINT, sigintHandler) sys.excepthook = qt.exceptionHandler timer = qt.QTimer() timer.start(500) # Application have to wake up Python interpreter, else SIGINT is not # catched timer.timeout.connect(lambda: None) settings = qt.QSettings(qt.QSettings.IniFormat, qt.QSettings.UserScope, "silx", "silx-view", None) if options.fresh_preferences: settings.clear() from .Viewer import Viewer window = Viewer(parent=None, settings=settings) window.setAttribute(qt.Qt.WA_DeleteOnClose, True) if options.use_opengl_plot: # It have to be done after the settings (after the Viewer creation) silx.config.DEFAULT_PLOT_BACKEND = "opengl" for filename in options.files: try: window.appendFile(filename) except IOError as e: _logger.error(e.args[0]) _logger.debug("Backtrace", exc_info=True) window.show() result = app.exec_() # remove ending warnings relative to QTimer app.deleteLater() return result
def mainQt(options): """Part of the main depending on Qt""" if options.debug: logging.root.setLevel(logging.DEBUG) # # Import most of the things here to be sure to use the right logging level # # Use max opened files hard limit as soft limit try: import resource except ImportError: _logger.debug("No resource module available") else: if hasattr(resource, 'RLIMIT_NOFILE'): try: hard_nofile = resource.getrlimit(resource.RLIMIT_NOFILE)[1] resource.setrlimit(resource.RLIMIT_NOFILE, (hard_nofile, hard_nofile)) except (ValueError, OSError): _logger.warning( "Failed to retrieve and set the max opened files limit") else: _logger.debug("Set max opened files to %d", hard_nofile) # This needs to be done prior to load HDF5 hdf5_file_locking = 'TRUE' if options.hdf5_file_locking else 'FALSE' _logger.info('Set HDF5_USE_FILE_LOCKING=%s', hdf5_file_locking) os.environ['HDF5_USE_FILE_LOCKING'] = hdf5_file_locking try: # it should be loaded before h5py import hdf5plugin # noqa except ImportError: _logger.debug("Backtrace", exc_info=True) import h5py import silx import silx.utils.files from silx.gui import qt # Make sure matplotlib is configured # Needed for Debian 8: compatibility between Qt4/Qt5 and old matplotlib import silx.gui.utils.matplotlib # noqa app = qt.QApplication([]) qt.QLocale.setDefault(qt.QLocale.c()) def sigintHandler(*args): """Handler for the SIGINT signal.""" qt.QApplication.quit() signal.signal(signal.SIGINT, sigintHandler) sys.excepthook = qt.exceptionHandler timer = qt.QTimer() timer.start(500) # Application have to wake up Python interpreter, else SIGINT is not # catched timer.timeout.connect(lambda: None) settings = qt.QSettings(qt.QSettings.IniFormat, qt.QSettings.UserScope, "silx", "silx-view", None) if options.fresh_preferences: settings.clear() window = createWindow(parent=None, settings=settings) window.setAttribute(qt.Qt.WA_DeleteOnClose, True) if options.use_opengl_plot: # It have to be done after the settings (after the Viewer creation) silx.config.DEFAULT_PLOT_BACKEND = "opengl" # NOTE: under Windows, cmd does not convert `*.tif` into existing files options.files = silx.utils.files.expand_filenames(options.files) for filename in options.files: # TODO: Would be nice to add a process widget and a cancel button try: window.appendFile(filename) except IOError as e: _logger.error(e.args[0]) _logger.debug("Backtrace", exc_info=True) window.show() result = app.exec() # remove ending warnings relative to QTimer app.deleteLater() return result
def mainQt(options): """Part of the main depending on Qt""" if options.debug: logging.root.setLevel(logging.DEBUG) # # Import most of the things here to be sure to use the right logging level # try: # it should be loaded before h5py import hdf5plugin # noqa except ImportError: _logger.debug("Backtrace", exc_info=True) import h5py import silx import silx.utils.files from silx.gui import qt # Make sure matplotlib is configured # Needed for Debian 8: compatibility between Qt4/Qt5 and old matplotlib from silx.gui.plot import matplotlib app = qt.QApplication([]) qt.QLocale.setDefault(qt.QLocale.c()) def sigintHandler(*args): """Handler for the SIGINT signal.""" qt.QApplication.quit() signal.signal(signal.SIGINT, sigintHandler) sys.excepthook = qt.exceptionHandler timer = qt.QTimer() timer.start(500) # Application have to wake up Python interpreter, else SIGINT is not # catched timer.timeout.connect(lambda: None) settings = qt.QSettings(qt.QSettings.IniFormat, qt.QSettings.UserScope, "silx", "silx-view", None) if options.fresh_preferences: settings.clear() from .Viewer import Viewer window = Viewer(parent=None, settings=settings) window.setAttribute(qt.Qt.WA_DeleteOnClose, True) if options.use_opengl_plot: # It have to be done after the settings (after the Viewer creation) silx.config.DEFAULT_PLOT_BACKEND = "opengl" # NOTE: under Windows, cmd does not convert `*.tif` into existing files options.files = silx.utils.files.expand_filenames(options.files) for filename in options.files: # TODO: Would be nice to add a process widget and a cancel button try: window.appendFile(filename) except IOError as e: _logger.error(e.args[0]) _logger.debug("Backtrace", exc_info=True) window.show() result = app.exec_() # remove ending warnings relative to QTimer app.deleteLater() return result
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) # PV names self.pv_names = loadPV() # ZMQ Ports self.zmqSendPort = 5301 self.zmqRecvPort = 5201 try: self.zmqSendSock = CONTEXT.socket(zmq.PUB) self.zmqSendSock.bind("tcp://*:" + str(self.zmqSendPort)) except: self.zmqSendSock = None print("Failed to bind to socket : {}".format(self.zmqSendPort)) # MainWindow Title self.setWindowTitle("DataViewer") # Initialize self._dragging = False self._last_y_axis_type = 0 self._last_tab_index = 0 self.plot_type = 'measure' self.start_timer = 0 self.settings = {} self.settings['E0'] = 8333 self.settings['sdd'] = False self.settings['ratio'] = 0.7 self.settings['plot_type'] = 'measure' self.settings['blink'] = False self.settings['scanCounts'] = 1 # DataBroker self.dbv1 = Broker.from_config(config) self.db = self.dbv1.v2 # Main QWidget main_panel = qt.QWidget(self) main_panel.setLayout(qt.QVBoxLayout()) self.setCentralWidget(main_panel) # Status Widget self.status = StatusWidget(self) self.status.setSizePolicy(qt.QSizePolicy.Expanding, qt.QSizePolicy.Fixed) # Intialize plot self.plot = Plot1DCustom(self, 'mpl') self.plot.getLegendsDockWidget().show() self.plot.setBackgroundColor('#FCF9F6') self.plot.setGraphXLabel("Energy [eV]") self.plot.setGraphYLabel("Counts [Arbs.]") self.plot.setDataMargins(0.01, 0.01, 0.01, 0.01) # Layout main_panel.layout().addWidget(self.status) main_panel.layout().addWidget(self.plot) # Adjust operation graph's margin(left, bottom, width height) self.plot._backend.ax.set_position([0.1, 0.05, 0.83, 0.93]) self.plot._backend.ax2.set_position([0.1, 0.05, 0.83, 0.93]) # self.updatePlotThread = UpdatePlotThread(self) # self.updatePlotThread.daemon = True # self.updatePlotThread.start() self.updatePlotThread = TestThread(self) self.updatePlotThread.daemon = True self.updatePlotThread.start() # Upper pannel for safety self.status.abortButton.clicked.connect(self.abortScan) # Manage zoom history of plot self.status.x_axis_type_combo_box.currentIndexChanged.connect( self.clearZoomHistory) self.status.y_axis_type_combo_box.currentIndexChanged.connect( self.clearZoomHistory) # Start ZMQ Recv Thread self.zmqRecvThread = QThreadFuture(self.receiveZmq) self.zmqRecvThread.start() if self.status: # RunEngine Notifier self._dummyIndex = 0 self.notifyTimer = qt.QTimer() self.notifyTimer.timeout.connect(self._notifyColor) self.notifyTimer.start(1000) # As a thread that monitors the DCM moving state, check the case # that it is normally located but is displaying as moving # self.checkDcmThread = CheckDcmThread() # self.checkDcmThread.daemon = True # self.checkDcmThread.start() # Connections self.status.num_of_history_spin_box.valueChanged.connect( self.updatePlotThread.trigger) self.status.x_axis_type_combo_box.currentIndexChanged.connect( self.updatePlotThread.trigger) self.status.y_axis_type_combo_box.currentIndexChanged.connect( self.updatePlotThread.trigger) self.status.derivativeCB.stateChanged.connect( self.updatePlotThread.trigger) # Check for dragging self.plot.sigPlotSignal.connect(self.checkDragging) # Initial query self.sendZmq('ViewerInitialized')
def __setThread(self, function, period): self.__timer = qt.QTimer() self.__timer.timeout[()].connect(function) self.__timer.start(period)
def __init__(self, function=None, period=1000): self.__timer = qt.QTimer() if function is None: function = self.test self._function = function self.__setThread(function, period)