def updateFrame(self):
image = self.device.image1.shaped_image.get()
if image is not None and len(image):
try:
image = self.preprocess(image)
except Exception as ex:
pass
# msg.logError(ex)
self.getting_frame = True
threads.invoke_in_main_thread(self._setFrame, image)
def load_element(self, element, candidate_infofile, plugin_info):
"""
Parameters
----------
element
candidate_infofile
plugin_info
Returns
-------
bool
True if the element matched a category, and will be accepted as a plugin
"""
target_plugin_info = None
for category_name in self.categories_interfaces:
try:
is_correct_subclass = issubclass(
element, self.categories_interfaces[category_name])
except Exception:
continue
if is_correct_subclass and element is not self.categories_interfaces[
category_name]:
current_category = category_name
if candidate_infofile not in self._category_file_mapping[
current_category]:
# we found a new plugin: initialise it and search for the next one
try:
threads.invoke_in_main_thread(self.instanciatePlugin,
plugin_info, element,
current_category)
except Exception as ex:
exc_info = sys.exc_info()
msg.logError(ex)
msg.logMessage("Unable to create plugin object: %s" %
plugin_info.path)
plugin_info.error = exc_info
# break # If it didn't work once it wont again
msg.logError(
RuntimeError(
"An error occurred while loading plugin: %s" %
plugin_info.path))
else:
# plugin_info.categories.append(current_category)
# self.category_mapping[current_category].append(plugin_info)
self._category_file_mapping[current_category].append(
candidate_infofile)
return True
def __init__(self):
# # Enforce global style within the console
# with open('xicam/gui/style.stylesheet', 'r') as f:
# style = f.read()
# style = (qdarkstyle.load_stylesheet() + style)
# Setup the kernel
self.kernel_manager = QtInProcessKernelManager()
self.kernel_manager.start_kernel()
kernel = self.kernel_manager.kernel
kernel.gui = 'qt'
# Push Xi-cam variables into the kernel
kernel.shell.push({
plugin.name: plugin
for plugin in pluginmanager.get_plugins_of_type("GUIPlugin") +
pluginmanager.get_plugins_of_type("EZPlugin")
})
# Observe plugin changes
pluginmanager.attach(self.pluginsChanged)
# Continue kernel setuppluginmanager.getPluginsOfCategory("GUIPlugin")
self.kernel_client = self.kernel_manager.client()
threads.invoke_in_main_thread(self.kernel_client.start_channels)
# Setup console widget
def stop():
self.kernel_client.stop_channels()
self.kernel_manager.shutdown_kernel()
control = RichJupyterWidget()
control.kernel_manager = self.kernel_manager
threads.invoke_in_main_thread(setattr, control, "kernel_client",
self.kernel_client)
control.exit_requested.connect(stop)
# control.style_sheet = style
control.syntax_style = u'monokai'
control.set_default_style(colors='Linux')
# Setup layout
self.stages = {'Terminal': GUILayout(control)}
# Save for later
self.kernel = kernel
super(IPythonPlugin, self).__init__()
def show_results(self):
header_labels_set = False
self.show_results_event.clear()
t0 = time.monotonic()
counter = 0
try:
msg.showBusy()
while not self._new_uids_queue.empty():
counter += 1
row = []
new_uid = self._new_uids_queue.get()
try:
entry = self.get_run_by_uid(new_uid)
row_data = self.apply_search_result_row(entry)
except SkipRow as e:
msg.showMessage(str(msg))
msg.logError(e)
continue
if not header_labels_set:
# Set header labels just once.
threads.invoke_in_main_thread(
self.search_results_model.setHorizontalHeaderLabels,
list(row_data))
header_labels_set = True
for value in row_data.values():
item = QStandardItem()
item.setData(value, Qt.DisplayRole)
item.setData(new_uid, Qt.UserRole)
row.append(item)
if QThread.currentThread().isInterruptionRequested():
self.show_results_event.set()
msg.logMessage("Interrupt requested")
return
threads.invoke_in_main_thread(
self.search_results_model.appendRow, row)
if counter:
self.sig_update_header.emit()
duration = time.monotonic() - t0
msg.showMessage("Displayed {} new results {}.".format(
counter, duration))
self.show_results_event.set()
except Exception as e:
msg.showMessage("Error displaying runs")
msg.logError(e)
finally:
msg.hideBusy()
def preview_catalog(self, catalog: BlueskyRun):
threads.invoke_in_main_thread(self.setText, "LOADING...")
try:
stream, field = bluesky_utils.guess_stream_field(catalog)
data = bluesky_utils.preview(catalog, stream, field)
threads.invoke_in_main_thread(self.setImage, data)
except Exception as ex:
msg.logError(ex)
threads.invoke_in_main_thread(self.imageitem.clear)
threads.invoke_in_main_thread(self.setText, "UNKNOWN DATA FORMAT")
def preview_catalog(self, catalog: BlueskyRun):
threads.invoke_in_main_thread(self.setText, "LOADING...")
try:
stream, field = self.guess_stream_field(catalog)
data = getattr(catalog, stream).to_dask()[field].squeeze()
for i in range(len(data.shape) - 2):
data = data[0]
threads.invoke_in_main_thread(self.setImage,
np.asarray(data.compute()))
except Exception as ex:
msg.logError(ex)
threads.invoke_in_main_thread(self.imageitem.clear)
threads.invoke_in_main_thread(self.setText, "UNKNOWN DATA FORMAT")
def preview_header(self, header: NonDBHeader):
try:
data = header.meta_array()[0]
threads.invoke_in_main_thread(self.setImage, data)
except IndexError:
threads.invoke_in_main_thread(self.imageitem.clear)
threads.invoke_in_main_thread(self.setText, "UNKNOWN DATA FORMAT")
def _update_thread(self, update_action: Callable):
while True:
if self.cached_frame is not None:
time.sleep(.01)
continue
t = time.time()
max_period = 1 / self.maxfps
current_elapsed = t - self._last_timestamp
if current_elapsed < max_period:
time.sleep(max_period - current_elapsed)
if not self.passive.isChecked():
break
if self.visibleRegion().isEmpty():
continue
try:
if not self.device.connected:
with msg.busyContext():
msg.showMessage('Connecting to device...')
self.device.wait_for_connection()
update_action()
except (RuntimeError, CaprotoTimeoutError, ConnectionTimeoutError,
TimeoutError) as ex:
threads.invoke_in_main_thread(
self.error_text.setText,
'An error occurred communicating with this device.')
msg.logError(ex)
except Exception as e:
threads.invoke_in_main_thread(
self.error_text.setText,
'Unknown error occurred when attempting to communicate with device.'
)
msg.logError(e)
def _update_thread(self, update_action:Callable):
while True:
if not self.passive.isChecked():
break
if self.visibleRegion().isEmpty():
time.sleep(1 / self.maxfps)
continue
try:
if not self.device.connected:
with msg.busyContext():
msg.showMessage('Connecting to device...')
self.device.wait_for_connection()
update_action()
except (RuntimeError, CaprotoTimeoutError, ConnectionTimeoutError, TimeoutError) as ex:
threads.invoke_in_main_thread(self.error_text.setText,
'An error occurred communicating with this device.')
msg.logError(ex)
except Exception as e:
threads.invoke_in_main_thread(self.error_text.setText,
'Unknown error occurred when attempting to communicate with device.')
msg.logError(e)
num_exposures_counter = self.device.cam.num_exposures_counter.get()
num_exposures = self.device.cam.num_exposures.get()
num_captured = self.device.hdf5.num_captured.get()
num_capture = self.device.hdf5.num_capture.get()
capturing = self.device.hdf5.capture.get()
if capturing:
current = num_exposures_counter + num_captured * num_exposures
total = num_exposures * num_capture
elif num_exposures == 1: # Show 'busy' for just one exposure
current = 0
total = 0
else:
current = num_exposures_counter
total = num_exposures
threads.invoke_in_main_thread(self._update_progress, current, total)
while self.getting_frame:
time.sleep(.01)
t = time.time()
max_period = 1 / self.maxfps
current_elapsed = t - self._last_timestamp
if current_elapsed < max_period:
time.sleep(max_period - current_elapsed)
self._last_timestamp = time.time()
def call_entries_finished(self, run):
invoke_in_main_thread(self._call_entries_result, run)
def _showProgress(self, progress: int, maxprogress: int):
threads.invoke_in_main_thread(msg.showProgress, progress, 0,
maxprogress)
def _get_frame(self):
self.cached_frame = self.device.image1.shaped_image.get()
threads.invoke_in_main_thread(self.updateFrame)
