def run_step_sweep(self, param_sweep_widget: ParamSweepWidget,
ui_inputs: List[List[str]]) -> None:
"""
Run a step in the active workflow as a sweep
i: index of step to run in the active workflow
parameter_inputs: Each dictionary has the same shape as a WorkflowStep.parameter_values
dictionary, but with the parameter values obtained from the UI instead of default values.
ui_inputs List[List[str]]: inputs for the sweep values from the sweep UI
type str: type of sweep, either "normal" or "grid"
"""
self.param_sweep_widget = param_sweep_widget
i: int = param_sweep_widget.step_number
parameter_inputs: Dict[str, Any] = param_sweep_widget.param_set
if not self._run_lock:
if parameter_inputs:
parameter_inputs_2: Dict[str, Any] = self._parse_inputs(
copy.deepcopy(parameter_inputs), ui_inputs)
self._worker: GeneratorWorker = create_worker(
self._run_step_sweep_grid, i, parameter_inputs,
parameter_inputs_2)
self._worker.yielded.connect(self._on_step_processed)
self._worker.started.connect(self._on_sweep_started)
self._worker.finished.connect(self.on_sweep_finished)
self._sweep_step = 0
self._worker.start()
else:
self._worker: GeneratorWorker = create_worker(
self._run_step_async, i, parameter_inputs)
self._worker.yielded.connect(self._on_step_processed)
self._worker.started.connect(self._on_sweep_started)
self._worker.finished.connect(self.on_sweep_finished)
self._worker.start()
def run_batch(self):
if not self._run_lock:
self._worker: GeneratorWorker = create_worker(
self._run_batch_async)
self._worker.yielded.connect(self._on_step_processed)
self._worker.started.connect(self._on_run_batch_started)
self._worker.aborted.connect(self._on_run_batch_aborted)
self._worker.finished.connect(self._on_run_batch_finished)
self._worker.start()
def run_next_step(self, parameter_inputs: Dict[str, Any]) -> None:
"""
Run the next step in the active workflow
parameter_inputs: Each dictionary has the same shape as a WorkflowStep.parameter_values
dictionary, but with the parameter values obtained from the UI instead of default values.
"""
if not self._run_lock:
self._worker: GeneratorWorker = create_worker(
self._run_next_step_async, parameter_inputs)
self._worker.yielded.connect(self._on_step_processed)
self._worker.started.connect(self._on_run_all_started)
self._worker.finished.connect(self._on_run_all_finished)
self._worker.start()
def _submit(
self, func: Callable, *args, _wait=True, **kwargs
) -> WorkerBase:
new_worker = create_worker(func, *args, _start_thread=False, **kwargs)
new_worker.finished.connect(self._start_next_worker)
if self.worker and self.worker.is_running:
self._next_worker = new_worker
if not _wait:
self.worker.quit()
else:
self.worker = new_worker
self.worker.start()
return new_worker
def run_step(self, i: int, parameter_inputs: Dict[str, Any]) -> None:
"""
Run a step in the active workflow
i int: index of step to run in the active workflow
parameter_inputs: Each dictionary has the same shape as a WorkflowStep.parameter_values
dictionary, but with the parameter values obtained from the UI instead of default values.
"""
if not self._run_lock:
selected_layers: List[Image] = self.viewer.get_active_layer()
cont: bool = True # continue execution
step_to_run: WorkflowStep = self.model.active_workflow.workflow_definition.steps[
i]
if len(step_to_run.parent) != len(selected_layers):
# too many or too few images selected as the input layer,
# abort run attempt and show warning
self.warn_box(
f"{step_to_run.name} requires {len(step_to_run.parent)} input images, "
f"but you have selected {len(selected_layers)} images."
f"\nPlease select {len(step_to_run.parent)} images by ctrl+clicking.",
"Wrong number of input images selected",
one_option=True,
)
cont = False # continue if user is running steps in order, and correct input steps are selected
else:
# check to see if correct layers were selected to run this segmentation in order
# some steps require multiple layers.
for selected_layer in selected_layers:
if selected_layer.name[:1].isdigit() and int(
selected_layer.name[:1]) not in step_to_run.parent:
# check to see if the correct image input layer is selected.
if i == 0:
response = self.warn_box(
f"You currently have the layer {selected_layer.name} selected in napari which will "
f"be used as the input layer. You will run this segmentation"
f" out of order. \nTo run the segmentation in order, "
f"please select the starting image (step 0) as the "
f"input layer for this step. "
f"\n Would you still like to continue?",
"Run segmentation out of order",
)
else:
step_required_name = self.model.active_workflow.workflow_definition.steps[
step_to_run.parent[0] - 1].name
response = self.warn_box(
f"You currently have the layer {selected_layer.name} selected in napari which will "
f"be used as the input layer. You will run this segmentation"
f" out of order. To run the segmentation in order, "
f"please select a layer that is the output of "
f"{i}. {step_required_name}."
f"\n Would you like to continue?",
"Run segmentation out of order",
)
cont = response == 1024
elif not selected_layer.name[:1].isdigit():
if i == 0:
response = self.warn_box(
f"You currently have the layer {selected_layer.name} selected in napari which will "
f"be used as the input layer. You will run this segmentation"
f" out of order. \nTo run the segmentation in order, "
f"please select the starting image (step 0) as the "
f"input layer for this step. "
f"\n Would you still like to continue?",
"Run segmentation out of order",
)
else:
step_required_name = self.model.active_workflow.workflow_definition.steps[
step_to_run.parent[0] - 1].name
response = self.warn_box(
f"You currently have the layer {selected_layer.name} selected in napari which will "
f"be used as the input layer. You will run this segmentation"
f" out of order. To run the segmentation in order, "
f"please select a layer that is the output of "
f"{i}. {step_required_name}."
f"\n Would you like to continue?",
"Run segmentation out of order",
)
cont = response == 1024
if cont:
self._worker: GeneratorWorker = create_worker(
self._run_step_async, i, parameter_inputs)
self._worker.yielded.connect(self._on_step_processed)
self._worker.started.connect(self._on_run_all_started)
self._worker.finished.connect(self._on_run_step_finished)
self._worker.start()