def test_custom_parameter(custom_parameter_workflow: Workflow, qtbot):
workflow_editor = WorkflowEditor(custom_parameter_workflow)
workflow_editor.show()
qtbot.addWidget(workflow_editor)
workflow_editor.workflowview.selectRow(
0
) # Note: models is empty here because pluginmanger hasn't finished load yet
def __init__(self):
self.workflow = Workflow()
self.headermodel = QStandardItemModel()
# self.alignmenttabview = TabView(self.headermodel)
self.rawtabview = TabView(self.headermodel,
widgetcls=RAWViewer,
field='primary')
self.recontabs = QTabWidget()
self.workfloweditor = WorkflowEditor(self.workflow)
self.workfloweditor.setHidden(True)
self.tomotoolbar = TomoToolbar()
self.tomotoolbar.sigSliceReconstruction.connect(self.sliceReconstruct)
self.tomotoolbar.sigFullReconstruction.connect(self.fullReconstruction)
self.stages = {
'Alignment':
GUILayout(QLabel('Alignment'),
right=self.workfloweditor,
top=self.tomotoolbar),
'Preprocess':
GUILayout(self.rawtabview,
right=self.workfloweditor,
top=self.tomotoolbar),
'Reconstruct':
GUILayout(self.recontabs,
top=self.tomotoolbar,
right=self.workfloweditor),
}
super(TomographyPlugin, self).__init__()
def test_custom_parameter(custom_parameter_workflow: Workflow, qtbot):
workflow_editor = WorkflowEditor(custom_parameter_workflow)
workflow_editor.show()
qtbot.addWidget(workflow_editor)
workflow_editor.workflowview.setCurrentIndex(
workflow_editor.workflowview.model().createIndex(0, 0)
) # Note: models is empty here because pluginmanger hasn't finished load yet
def test_view(simple_workflow_with_intents, qtbot):
# Tests ingesting an internally run workflow, projecting it, storing it in a model
# and using a CanvasView to display it
@live_plugin('PlotMixinPlugin')
class PlotMixinTest(PlotWidget):
def __init__(self, *args, **kwargs):
super(PlotMixinTest, self).__init__(*args,
background='g',
**kwargs)
@live_plugin('ImageMixinPlugin')
class ImageMixinTest(ImageView):
def __init__(self, *args, **kwargs):
super(ImageMixinTest, self).__init__(*args, **kwargs)
self.setStyleSheet('* {background-color:green;}')
execution.executor = LocalExecutor()
ensemble_model = EnsembleModel()
intents_model = IntentsModel()
intents_model.setSourceModel(ensemble_model)
data_selector_view = DataSelectorView()
data_selector_view.setModel(ensemble_model)
stacked_canvas_view = StackedCanvasView()
stacked_canvas_view.setModel(intents_model)
widget = QWidget()
layout = QHBoxLayout()
layout.addWidget(stacked_canvas_view)
layout.addWidget(data_selector_view)
widget.setLayout(layout)
def showResult(*result):
ensemble = Ensemble()
doc_generator = ingest_result_set(simple_workflow_with_intents, result)
documents = list(doc_generator)
catalog = BlueskyInMemoryCatalog()
catalog.upsert(documents[0][1], documents[-1][1], ingest_result_set,
[simple_workflow_with_intents, result], {})
catalog = catalog[-1]
ensemble.append_catalog(catalog)
ensemble_model.add_ensemble(ensemble, project_intents)
qtbot.wait(1000)
root = ensemble_model.index(0, 0, QModelIndex())
ensemble_model.setData(root.child(0, 0), True, Qt.CheckStateRole)
widget.setMinimumSize(800, 600)
widget.show()
qtbot.addWidget(widget)
workflow_editor = WorkflowEditor(simple_workflow_with_intents,
callback_slot=showResult)
workflow_editor.run_workflow()
qtbot.wait(3000)
def test_menu(simple_workflow, qtbot):
manager.qt_is_safe = True
manager.initialize_types()
manager.collect_plugins()
workflow_editor = WorkflowEditor(simple_workflow)
workflow_editor.show()
qtbot.addWidget(workflow_editor)
def test_menu(qtbot):
workflow_editor = WorkflowEditor(Workflow())
workflow_editor.show()
qtbot.addWidget(workflow_editor)
manager.qt_is_safe = True
manager.initialize_types()
manager.collect_plugins()
qtbot.wait(10000)
def test_workflow_selector(simple_workflow: Workflow,
custom_parameter_workflow: Workflow, square_op,
qtbot):
workflow_editor = WorkflowEditor(simple_workflow,
workflows={
simple_workflow: 'Simple',
custom_parameter_workflow: "Custom"
})
simple_workflow.add_operation(square_op.clone())
workflow_editor.show()
qtbot.addWidget(workflow_editor)
def __init__(self):
# Set up an invert operation
@OperationPlugin
@output_names('inverted_data')
def invert(data: np.ndarray = None) -> np.ndarray:
if issubclass(data.dtype.type, np.integer):
max = np.iinfo(data.dtype).max
else:
max = np.finfo(data.dtype).max
return max - data
# Set up our workflow
workflow = Workflow()
workflow.add_operation(invert)
workflow_editor = WorkflowEditor(workflow)
# Set up a GUI layout
center_widget = QLabel("test")
sample_stage_layout = GUILayout(center_widget)
# Set up stages
stages = {
"Sample Stage": GUILayout(center_widget, right=workflow_editor)
}
self.stages = stages
super(SamplePlugin, self).__init__()
def __init__(self, *args, **kwargs):
super(EnsembleGUIPlugin, self).__init__(*args, **kwargs)
self._projectors = [] # List[Callable[[BlueskyRun], List[Intent]]]
self.ensemble_model = EnsembleModel()
self.intents_model = IntentsModel()
self.intents_model.setSourceModel(self.ensemble_model)
self.ensemble_view = DataSelectorView()
self.ensemble_view.setModel(self.ensemble_model)
self.canvases_view = StackedCanvasView()
self.canvases_view.setModel(self.intents_model)
self.canvases_view.sigInteractiveAction.connect(self.process_action)
self.workflow_editor = WorkflowEditor(Workflow())
self.xi_help = HelpWidget()
self.gui_layout_template = {
"center": self.canvases_view,
"right": self.ensemble_view,
"rightbottom": self.workflow_editor,
"leftbottom": self.xi_help
}
def __init__(self, *args, **kwargs):
"""Constructs the ExamplePlugin
This will set up the widgets that we want the ExamplePlugin to have,
the layout for the widgets (how the interface will look) in the ExamplePlugin,
and an example workflow.
"""
self._catalog_viewer = CatalogView(
) # Create a widget to view the loaded catalog
self._results_viewer = DynImageView(
) # Create a widget to view the result image
self._workflow = ExampleWorkflow() # Create a workflow
# Create a widget for the workflow; this shows the operations and their paramters,
# and we can run the workflow with this widget
self._workflow_editor = WorkflowEditor(workflow=self._workflow)
# The WorkflowEditor emits a "sigRunWorkflow" signal when its "Run Workflow" is clicked
# This will call our run_workflow method whenever this signal is emitted (whenever the button is clicked).
self._workflow_editor.sigRunWorkflow.connect(self.run_workflow)
# Create a layout to organize our widgets
# The first argument (which corresponds to the center widget) is required.
catalog_viewer_layout = GUILayout(self._catalog_viewer,
right=self._workflow_editor,
bottom=self._results_viewer)
# Create a "View" stage that has the catalog viewer layout
self.stages = {"View": catalog_viewer_layout}
# For classes derived from GUIPlugin, this super __init__ must occur at end
super(ExamplePlugin, self).__init__(*args, **kwargs)
def __init__(self):
self.workflow = Workflow()
self.workfloweditor = WorkflowEditor(
self.workflow,
callback_slot=self.showResult,
except_slot=lambda *_: self.workflow._pretty_print())
self.ensemble_model = EnsembleModel()
data_selector_view = DataSelectorView()
data_selector_view.setModel(self.ensemble_model)
# Our results views' model (should only contain intents)
intents_model = IntentsModel()
intents_model.setSourceModel(self.ensemble_model)
# Our results view widget container
results_view = StackedCanvasView()
results_view.setModel(intents_model)
self.stages = {
'Testing':
GUILayout(results_view,
left=None,
righttop=data_selector_view,
right=self.workfloweditor),
}
super(WorkflowEditorPlugin, self).__init__()
def __init__(self):
super(MapStage, self).__init__()
self.canvases_view = StackedCanvasView()
self.canvases_view.setModel(self.intents_model)
self.preprocess_workflow = Workflow()
self.preprocess_editor = WorkflowEditor(
self.preprocess_workflow,
callback_slot=self.append_result,
# finished_slot=self.append_result,
kwargs_callable=self.treatment_kwargs)
self.stages["Map"] = GUILayout(self.catalog_viewer,
right=self.preprocess_editor,
bottom=self.canvases_view,
righttop=self.data_selector_view)
def __init__(self, *args, **kwargs):
"""
"""
# self._catalog_viewer = CatalogView() # Create a widget to view the loaded catalog
# self._results_viewer = DynImageView() # Create a widget to view the result image
self._workflow = MapWorkflow() # Create a workflow
# Create a widget for the workflow; this shows the operations and their parameters,
# and we can run the workflow with this widget
self._workflow_editor = WorkflowEditor(workflow=self._workflow)
# The WorkflowEditor emits a "sigRunWorkflow" signal when its "Run Workflow" is clicked
# This will call our run_workflow method whenever this signal is emitted (whenever the button is clicked).
self._workflow_editor.sigRunWorkflow.connect(self.run_workflow)
# Create a layout to organize our widgets
# The first argument (which corresponds to the center widget) is required.
catalog_viewer_layout = GUILayout(self._catalog_viewer,
right=self._workflow_editor,
bottom=self._results_viewer)
super(RegisterStack, self).__init__(*args, **kwargs)
def test_simple(simple_workflow: Workflow, square_op, qtbot):
workflow_editor = WorkflowEditor(simple_workflow)
simple_workflow.add_operation(square_op.clone())
workflow_editor.show()
qtbot.addWidget(workflow_editor)
def test_view(simple_workflow_with_intents, qtbot):
# Tests ingesting an internally run workflow, projecting it, storing it in a model
# and using a CanvasView to display it
plugin_manager.qt_is_safe = True
plugin_manager.initialize_types()
plugin_manager.collect_plugins()
pc = next(
filter(lambda task: task.name == 'plot_canvas', plugin_manager._tasks))
plugin_manager._load_plugin(pc)
plugin_manager._instantiate_plugin(pc)
ic = next(
filter(lambda task: task.name == 'image_canvas',
plugin_manager._tasks))
plugin_manager._load_plugin(ic)
plugin_manager._instantiate_plugin(ic)
plot_intent_task = next(
filter(lambda task: task.name == 'PlotIntent', plugin_manager._tasks))
plugin_manager._load_plugin(plot_intent_task)
plugin_manager._instantiate_plugin(plot_intent_task)
image_intent_task = next(
filter(lambda task: task.name == 'ImageIntent', plugin_manager._tasks))
plugin_manager._load_plugin(image_intent_task)
plugin_manager._instantiate_plugin(image_intent_task)
execution.executor = LocalExecutor()
ensemble_model = EnsembleModel()
intents_model = IntentsModel()
intents_model.setSourceModel(ensemble_model)
data_selector_view = DataSelectorView()
data_selector_view.setModel(ensemble_model)
stacked_canvas_view = StackedCanvasView()
stacked_canvas_view.setModel(intents_model)
widget = QWidget()
layout = QHBoxLayout()
layout.addWidget(stacked_canvas_view)
layout.addWidget(data_selector_view)
widget.setLayout(layout)
def showResult(*result):
ensemble = Ensemble()
doc_generator = ingest_result_set(simple_workflow_with_intents, result)
documents = list(doc_generator)
catalog = BlueskyInMemoryCatalog()
catalog.upsert(documents[0][1], documents[-1][1], ingest_result_set,
[simple_workflow_with_intents, result], {})
catalog = catalog[-1]
ensemble.append_catalog(catalog)
ensemble_model.add_ensemble(ensemble, project_intents)
qtbot.wait(1000)
root = ensemble_model.index(0, 0, QModelIndex())
ensemble_model.setData(root.child(0, 0), True, Qt.CheckStateRole)
widget.setMinimumSize(800, 600)
widget.show()
qtbot.addWidget(widget)
workflow_editor = WorkflowEditor(simple_workflow_with_intents,
callback_slot=showResult)
workflow_editor.run_workflow()
qtbot.wait(7000)
def __init__(self):
# Late imports required due to plugin system
from xicam.SAXS.calibration import CalibrationPanel
from xicam.SAXS.widgets.SAXSViewerPlugin import SAXSCalibrationViewer, SAXSMaskingViewer, SAXSReductionViewer
from xicam.SAXS.widgets.SAXSToolbar import SAXSToolbarRaw, SAXSToolbarMask, SAXSToolbarReduce
from xicam.SAXS.widgets.XPCSToolbar import XPCSToolBar
self.derivedDataModel = DerivedDataModel()
self.catalogModel = QStandardItemModel()
# Data model
self.catalogModel = QStandardItemModel()
self.selectionmodel = QItemSelectionModel(self.catalogModel)
# Initialize workflows
self.maskingworkflow = MaskingWorkflow()
self.simulateworkflow = SimulateWorkflow()
self.displayworkflow = DisplayWorkflow()
self.reduceworkflow = ReduceWorkflow()
self.roiworkflow = ROIWorkflow()
# Grab the calibration plugin
self.calibrationsettings = pluginmanager.get_plugin_by_name('xicam.SAXS.calibration',
'SettingsPlugin')
# Setup TabViews
# FIXME -- rework how fields propagate to displays (i.e. each image has its own detector, switching
# between tabs updates the detector combobbox correctly)
field = "fccd_image"
self.calibrationtabview = TabView(self.catalogModel, widgetcls=SAXSCalibrationViewer,
stream='primary', field=field,
selectionmodel=self.selectionmodel,
bindings=[(self.calibrationsettings.sigGeometryChanged, 'setGeometry')],
geometry=self.getAI)
self.masktabview = TabView(self.catalogModel, widgetcls=SAXSMaskingViewer, selectionmodel=self.selectionmodel,
stream='primary', field=field,
bindings=[('sigTimeChangeFinished', self.indexChanged),
(self.calibrationsettings.sigGeometryChanged, 'setGeometry')],
geometry=self.getAI)
self.reducetabview = TabView(self.catalogModel, widgetcls=SAXSReductionViewer,
selectionmodel=self.selectionmodel,
stream='primary', field=field,
bindings=[('sigTimeChangeFinished', self.indexChanged),
(self.calibrationsettings.sigGeometryChanged, 'setGeometry')],
geometry=self.getAI)
self.comparemultiview = QLabel("COMING SOON!") # SAXSMultiViewerPlugin(self.catalogModel, self.selectionmodel)
# Setup correlation views
self.correlationView = TabView(self.catalogModel, widgetcls=SAXSReductionViewer,
selectionmodel=self.selectionmodel,
stream='primary', field=field)
self.twoTimeProcessor = TwoTimeParameterTree(processor=self.processTwoTime)
self.twoTimeToolBar = XPCSToolBar(headermodel=self.catalogModel,
selectionmodel=self.selectionmodel,
view=self.correlationView.currentWidget,
workflow=self.roiworkflow,
index=0)
self.oneTimeProcessor = OneTimeParameterTree(processor=self.processOneTime)
self.oneTimeToolBar = XPCSToolBar(view=self.correlationView.currentWidget,
workflow=self.roiworkflow,
index=0)
# Setup toolbars
self.rawtoolbar = SAXSToolbarRaw(self.catalogModel, self.selectionmodel)
self.masktoolbar = SAXSToolbarMask(self.catalogModel, self.selectionmodel)
self.reducetoolbar = SAXSToolbarReduce(self.catalogModel, self.selectionmodel,
view=self.reducetabview.currentWidget, workflow=self.reduceworkflow)
self.reducetabview.kwargs['toolbar'] = self.reducetoolbar
self.reducetoolbar.sigDeviceChanged.connect(self.deviceChanged)
# Setup calibration widgets
self.calibrationsettings.setModels(self.catalogModel, self.calibrationtabview.selectionmodel)
self.calibrationpanel = CalibrationPanel(self.catalogModel, self.calibrationtabview.selectionmodel)
self.calibrationpanel.sigDoCalibrateWorkflow.connect(self.doCalibrateWorkflow)
self.calibrationsettings.sigGeometryChanged.connect(self.doSimulateWorkflow)
# Setup masking widgets
self.maskeditor = WorkflowEditor(self.maskingworkflow)
self.maskeditor.sigWorkflowChanged.connect(self.doMaskingWorkflow)
# Setup reduction widgets
self.displayeditor = WorkflowEditor(self.displayworkflow)
self.reduceeditor = WorkflowEditor(self.reduceworkflow)
self.reduceplot = DerivedDataWidget(self.derivedDataModel)
self.reducetoolbar.sigDoWorkflow.connect(self.doReduceWorkflow)
self.reduceeditor.sigWorkflowChanged.connect(self.doReduceWorkflow)
self.displayeditor.sigWorkflowChanged.connect(self.doDisplayWorkflow)
self.reducetabview.currentChanged.connect(self.catalogChanged)
# Setup correlation widgets
self.correlationResults = DerivedDataWidget(self.derivedDataModel)
self.stages = {
'Calibrate': GUILayout(self.calibrationtabview,
right=self.calibrationsettings.widget,
rightbottom=self.calibrationpanel,
top=self.rawtoolbar),
'Mask': GUILayout(self.masktabview,
right=self.maskeditor,
top=self.masktoolbar),
'Reduce': GUILayout(self.reducetabview,
bottom=self.reduceplot, right=self.reduceeditor, righttop=self.displayeditor,
top=self.reducetoolbar),
'Compare': GUILayout(self.comparemultiview, top=self.reducetoolbar, bottom=self.reduceplot,
right=self.reduceeditor),
'Correlate': {
'2-Time Correlation': GUILayout(self.correlationView,
top=self.twoTimeToolBar,
rightbottom=self.twoTimeProcessor,
bottom=self.correlationResults),
'1-Time Correlation': GUILayout(self.correlationView,
top=self.oneTimeToolBar,
rightbottom=self.oneTimeProcessor,
bottom=self.correlationResults)
}
}
super(SAXSPlugin, self).__init__()
# Start visualizations
self.displayworkflow.visualize(self.reduceplot, imageview=lambda: self.reducetabview.currentWidget(),
toolbar=self.reducetoolbar)
def test_simple(simple_workflow: Workflow, qtbot):
workflow_editor = WorkflowEditor(simple_workflow)
workflow_editor.show()
qtbot.addWidget(workflow_editor)
def __init__(self, *args, **kwargs):
self.active_filename = ""
self._main_view = QMainWindow()
self._main_view.setCentralWidget(QWidget())
self._main_view.centralWidget().hide()
self._editors = QStackedWidget()
self.workflow_process_selector = QComboBox()
self.workflow_process_selector.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
self.workflow_process_selector.addItem("TomoPy Workflow")
self._workflow = None
self._tomo_workflow = TomographyWorkflow() # Create a workflow
self._workflow = self._tomo_workflow
self._workflow_editor = WorkflowEditor(workflow=self._workflow)
self._workflow_editor.sigRunWorkflow.connect(self.run_workflow)
self._active_workflow_executor = QTreeWidget()
self._editors.addWidget(self._workflow_editor)
if hasLTT:
self._alt_workflow = LTTWorkflow()
self.workflow_process_selector.addItem("LTT Workflow")
self._alt_workflow_editor = WorkflowEditor(self._alt_workflow)
self._alt_workflow_editor.sigRunWorkflow.connect(self.run_workflow)
self._editors.addWidget(self._alt_workflow_editor)
self.workflow_process_selector.setCurrentIndex(0)
self.workflow_process_selector.currentIndexChanged.connect(self.active_workflow_changed)
self._active_workflow_widget = QWidget()
self._active_layout = QVBoxLayout()
self._active_layout.addWidget(self.workflow_process_selector)
self._active_layout.addWidget(self._editors)
self._active_layout.addWidget(self._active_workflow_executor)
self._active_workflow_widget.setLayout(self._active_layout)
# self.hdf5_viewer = HDFTreeViewer()
# self.hdf5_viewer.load("/Users/hari/20200521_160002_heartbeat_test.h5")
self.top_controls = QWidget()
self.top_controls_layout = QHBoxLayout()
self.top_controls.setLayout(self.top_controls_layout)
self.top_controls_add_new_selector = QComboBox()
self.top_controls_frequency_selector = QSpinBox()
self.top_controls_frequency_selector.setValue(0)
self.top_controls_add_new_viewer = QPushButton()
self.top_controls_add_new_viewer.setText("Add Viewer")
self.top_controls_add_new_viewer.clicked.connect(self.add_new_viewer_selected)
self.top_controls_preview = QPushButton()
self.top_controls_preview.setText("Preview")
self.top_controls_preview.clicked.connect(self.preview_workflows)
self.top_controls_execute = QPushButton()
self.top_controls_execute.setText("Execute All")
self.top_controls_execute.clicked.connect(self.execute_workflows)
self.top_controls_add_new_selector.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.top_controls_add_new_viewer.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.top_controls_execute.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.top_controls_frequency_selector.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.top_controls_layout.addWidget(self.top_controls_add_new_selector)
self.top_controls_layout.addWidget(self.top_controls_add_new_viewer)
self.top_controls_layout.addWidget(self.top_controls_frequency_selector)
self.top_controls_layout.addWidget(self.top_controls_preview)
self.top_controls_layout.addWidget(self.top_controls_execute)
self.top_controls.setLayout(self.top_controls_layout)
self.status_bar = QLabel("None Loaded...")
# Create a layout to organize our widgets
# The first argument (which corresponds to the center widget) is required.
catalog_viewer_layout = GUILayout(self._main_view,
top=self.top_controls,
right=self._active_workflow_widget,
bottom=self.status_bar)
# Create a "View" stage that has the catalog viewer layout
self.stages = {"View": catalog_viewer_layout}
self.active_workflows = []
# For classes derived from GUIPlugin, this super __init__ must occur at end
super(TomographyPlugin, self).__init__(*args, **kwargs)
class TomographyPlugin(GUIPlugin):
name = 'Tomography'
sigLog = Signal(int, str, str, np.ndarray)
slice = 0
multislice = 1
preview3d = 2
fullrecon = 3
def __init__(self):
self.workflow = Workflow()
self.headermodel = QStandardItemModel()
# self.alignmenttabview = TabView(self.headermodel)
self.rawtabview = TabView(self.headermodel,
widgetcls=RAWViewer,
field='primary')
self.recontabs = QTabWidget()
self.workfloweditor = WorkflowEditor(self.workflow)
self.workfloweditor.setHidden(True)
self.tomotoolbar = TomoToolbar()
self.tomotoolbar.sigSliceReconstruction.connect(self.sliceReconstruct)
self.tomotoolbar.sigFullReconstruction.connect(self.fullReconstruction)
self.stages = {
'Alignment':
GUILayout(QLabel('Alignment'),
right=self.workfloweditor,
top=self.tomotoolbar),
'Preprocess':
GUILayout(self.rawtabview,
right=self.workfloweditor,
top=self.tomotoolbar),
'Reconstruct':
GUILayout(self.recontabs,
top=self.tomotoolbar,
right=self.workfloweditor),
}
super(TomographyPlugin, self).__init__()
def appendHeader(self, header: NonDBHeader, **kwargs):
item = QStandardItem(header.startdoc.get('sample_name', '????'))
item.header = header
self.headermodel.appendRow(item)
self.headermodel.dataChanged.emit(QModelIndex(), QModelIndex())
def sliceReconstruct(self):
currentitem = self.headermodel.item(self.rawtabview.currentIndex())
if not currentitem:
msg.showMessage(
'Error: You must open files before reconstructing.')
try:
msg.showBusy()
msg.showMessage('Running slice reconstruction...', level=msg.INFO)
path = self.headermodel.item(
self.rawtabview.currentIndex()).header.startdoc['path']
self.workflow.execute(
None,
path=path,
threadkey='slicereconstruct',
callback_slot=partial(self.showReconstruction,
mode=self.slice),
except_slot=self.exceptionCallback)
except Exception as ex:
msg.logError(ex)
msg.showReady()
msg.clearMessage()
def fullReconstruction(self):
volumeviewer = VolumeViewer()
self.recontabs.addTab(volumeviewer, '????')
currentitem = self.headermodel.item(self.rawtabview.currentIndex())
if not currentitem:
msg.showMessage(
'Error: You must open files before reconstructing.')
try:
msg.showBusy()
msg.showMessage('Running slice reconstruction...', level=msg.INFO)
currentheader = self.headermodel.item(
self.rawtabview.currentIndex()).header
readprocess = self.workflow.processes[
0] # hopefully! TODO: require a readprocess first
readprocess.path.value = currentheader.startdoc['path']
numofsinograms = currentheader.meta_array('primary').shape[1]
executor = DaskExecutor()
client = distributed.Client()
def chunkiterator(workflow):
for i in range(0, int(numofsinograms),
int(readprocess.chunksize.value)):
readprocess.sinoindex.value = i
yield executor.execute(workflow)
_reconthread = QThreadFutureIterator(
chunkiterator,
self.workflow,
callback_slot=partial(self.showReconstruction,
mode=self.fullrecon),
except_slot=self.exceptionCallback)
_reconthread.start()
except Exception as ex:
msg.logError(ex)
msg.showReady()
msg.clearMessage()
def exceptionCallback(self, ex):
msg.notifyMessage("Reconstruction failed;\n see log for error")
msg.showMessage("Reconstruction failed; see log for error")
msg.logError(ex)
msg.showReady()
def showReconstruction(self, result, mode):
print('result:', result)
if mode == self.slice:
sliceviewer = SliceViewer()
sliceviewer.setImage(list(result.values())[0].value.squeeze())
self.recontabs.addTab(sliceviewer, '????')
if mode == self.fullrecon:
self.recontabs.widget(self.recontabs.count() - 1).appendData(
list(result.values())[0].value[::4, ::4, ::4])
msg.showReady()
def __init__(self):
# Late imports required due to plugin system
from xicam.SAXS.calibration import CalibrationPanel
from xicam.SAXS.widgets.SAXSMultiViewer import SAXSMultiViewerPlugin
from xicam.SAXS.widgets.SAXSViewerPlugin import SAXSViewerPluginBase, SAXSCalibrationViewer, SAXSMaskingViewer, \
SAXSReductionViewer
from xicam.SAXS.widgets.SAXSToolbar import SAXSToolbar
from xicam.SAXS.widgets.SAXSSpectra import SAXSSpectra
# Data model
self.headermodel = QStandardItemModel()
self.selectionmodel = QItemSelectionModel(self.headermodel)
# Initialize workflows
self.maskingworkflow = MaskingWorkflow()
self.simulateworkflow = SimulateWorkflow()
self.displayworkflow = DisplayWorkflow()
self.reduceworkflow = ReduceWorkflow()
# Grab the calibration plugin
self.calibrationsettings = pluginmanager.getPluginByName(
'xicam.SAXS.calibration', 'SettingsPlugin').plugin_object
print(
pluginmanager.getPluginByName('xicam.SAXS.calibration',
'SettingsPlugin').path)
# Setup TabViews
self.calibrationtabview = TabView(
self.headermodel,
widgetcls=SAXSCalibrationViewer,
selectionmodel=self.selectionmodel,
bindings=[(self.calibrationsettings.sigGeometryChanged,
'setGeometry')],
geometry=self.getAI)
self.masktabview = TabView(
self.headermodel,
widgetcls=SAXSMaskingViewer,
selectionmodel=self.selectionmodel,
bindings=[('sigTimeChangeFinished', self.indexChanged),
(self.calibrationsettings.sigGeometryChanged,
'setGeometry')],
geometry=self.getAI)
self.reducetabview = TabView(
self.headermodel,
widgetcls=SAXSReductionViewer,
selectionmodel=self.selectionmodel,
bindings=[('sigTimeChangeFinished', self.indexChanged),
(self.calibrationsettings.sigGeometryChanged,
'setGeometry')],
geometry=self.getAI)
self.comparemultiview = SAXSMultiViewerPlugin(self.headermodel,
self.selectionmodel)
# self.tabviewsynchronizer = TabViewSynchronizer(
# [self.calibrationtabview, self.masktabview, self.reducetabview, self.comparemultiview.leftTabView])
# Setup toolbars
self.toolbar = SAXSToolbar(self.headermodel, self.selectionmodel)
self.calibrationtabview.kwargs['toolbar'] = self.toolbar
self.reducetabview.kwargs['toolbar'] = self.toolbar
# Setup calibration widgets
self.calibrationsettings.setModels(
self.headermodel, self.calibrationtabview.selectionmodel)
self.calibrationpanel = CalibrationPanel(
self.headermodel, self.calibrationtabview.selectionmodel)
self.calibrationpanel.sigDoCalibrateWorkflow.connect(
self.doCalibrateWorkflow)
self.calibrationsettings.sigGeometryChanged.connect(
self.doSimulateWorkflow)
# Setup masking widgets
self.maskeditor = WorkflowEditor(self.maskingworkflow)
self.maskeditor.sigWorkflowChanged.connect(self.doMaskingWorkflow)
# Setup reduction widgets
self.displayeditor = WorkflowEditor(self.displayworkflow)
self.reduceeditor = WorkflowEditor(self.reduceworkflow)
self.reduceplot = SAXSSpectra(self.reduceworkflow, self.toolbar)
self.toolbar.sigDoWorkflow.connect(partial(self.doReduceWorkflow))
self.reduceeditor.sigWorkflowChanged.connect(self.doReduceWorkflow)
self.displayeditor.sigWorkflowChanged.connect(self.doDisplayWorkflow)
self.reducetabview.currentChanged.connect(self.headerChanged)
self.reducetabview.currentChanged.connect(self.headerChanged)
# Setup more bindings
self.calibrationsettings.sigSimulateCalibrant.connect(
partial(self.doSimulateWorkflow))
self.stages = {
'Calibrate':
GUILayout(
self.calibrationtabview,
# pluginmanager.getPluginByName('SAXSViewerPlugin', 'WidgetPlugin').plugin_object()
right=self.calibrationsettings.widget,
rightbottom=self.calibrationpanel,
top=self.toolbar),
'Mask':
GUILayout(self.masktabview,
right=self.maskeditor,
top=self.toolbar),
'Reduce':
GUILayout(self.reducetabview,
bottom=self.reduceplot,
right=self.reduceeditor,
righttop=self.displayeditor,
top=self.toolbar),
'Compare':
GUILayout(self.comparemultiview,
top=self.toolbar,
bottom=self.reduceplot,
right=self.reduceeditor)
}
super(SAXSPlugin, self).__init__()
# Start visualizations
self.displayworkflow.visualize(
self.reduceplot,
imageview=lambda: self.reducetabview.currentWidget(),
toolbar=self.toolbar)
def __init__(self):
# Data model
self.headermodel = QStandardItemModel()
# Initialize workflows
self.maskingworkflow = MaskingWorkflow()
self.simulateworkflow = SimulateWorkflow()
self.displayworkflow = DisplayWorkflow()
self.reduceworkflow = ReduceWorkflow()
# Setup TabViews
self.calibrationtabview = TabView(self.headermodel,
pluginmanager.getPluginByName('SAXSViewerPlugin',
'WidgetPlugin').plugin_object,
'primary')
self.masktabview = TabView(self.headermodel,
pluginmanager.getPluginByName('SAXSViewerPlugin', 'WidgetPlugin').plugin_object,
'primary')
self.reducetabview = TabView(self.headermodel,
pluginmanager.getPluginByName('SAXSViewerPlugin', 'WidgetPlugin').plugin_object,
'primary', bindings=[('sigTimeChangeFinished', self.indexChanged)])
self.comparemultiview = SAXSMultiViewerPlugin(self.headermodel)
self.tabviewsynchronizer = TabViewSynchronizer(
[self.calibrationtabview, self.masktabview, self.reducetabview, self.comparemultiview.leftTabView])
# Setup toolbars
self.calibrationtoolbar = SAXSToolbar(self.calibrationtabview, workflow=self.reduceworkflow)
self.reducetoolbar = SAXSToolbar(self.reducetabview, workflow=self.reduceworkflow)
self.calibrationtabview.kwargs['toolbar'] = self.calibrationtoolbar
self.reducetabview.kwargs['toolbar'] = self.reducetoolbar
# Setup calibration widgets
self.calibrationsettings = pluginmanager.getPluginByName('DeviceProfiles', 'SettingsPlugin').plugin_object
self.calibrationsettings.setModels(self.headermodel, self.calibrationtabview.selectionmodel)
self.calibrationpanel = CalibrationPanel()
self.calibrationpanel.setModels(self.headermodel, self.calibrationtabview.selectionmodel)
self.calibrationpanel.sigDoCalibrateWorkflow.connect(self.doCalibrateWorkflow)
# Setup masking widgets
self.maskeditor = WorkflowEditor(self.maskingworkflow)
self.maskeditor.sigWorkflowChanged.connect(self.doMaskingWorkflow)
# Setup reduction widgets
self.displayeditor = WorkflowEditor(self.displayworkflow)
self.reduceworkflow.attach(partial(self.doReduceWorkflow, self.reduceworkflow))
self.reduceeditor = WorkflowEditor(self.reduceworkflow)
self.reduceplot = SAXSSpectra(self.reduceworkflow, self.reducetoolbar)
self.reducetoolbar.sigDoWorkflow.connect(partial(self.doReduceWorkflow, self.reduceworkflow))
self.reduceeditor.sigWorkflowChanged.connect(self.doReduceWorkflow)
self.displayeditor.sigWorkflowChanged.connect(self.doDisplayWorkflow)
self.reducetabview.currentChanged.connect(partial(self.doReduceWorkflow, self.reduceworkflow))
self.reducetabview.currentChanged.connect(partial(self.doDisplayWorkflow, self.displayworkflow))
# Setup more bindings
self.calibrationsettings.sigSimulateCalibrant.connect(partial(self.doSimulateWorkflow, self.simulateworkflow))
self.stages = {
'Calibrate': GUILayout(self.calibrationtabview,
# pluginmanager.getPluginByName('SAXSViewerPlugin', 'WidgetPlugin').plugin_object()
right=self.calibrationsettings.widget,
rightbottom=self.calibrationpanel,
top=self.calibrationtoolbar),
'Mask': GUILayout(self.masktabview,
right=self.maskeditor),
'Reduce': GUILayout(self.reducetabview,
bottom=self.reduceplot, right=self.reduceeditor, righttop=self.displayeditor,
top=self.reducetoolbar),
'Compare': GUILayout(self.comparemultiview, top=self.reducetoolbar, bottom=self.reduceplot,
right=self.reduceeditor)
}
super(SAXSPlugin, self).__init__()
