def __init__(self,
headless=False,
workflow_cmdline_args=(),
parent=None,
graph=None):
# Create a graph to be shared by all operators
graph = Graph()
super(LabelImageViewerWorkflow,
self).__init__(headless=headless,
workflow_cmdline_args=workflow_cmdline_args,
parent=parent,
graph=graph)
self._applets = []
# Two data selection applets...
self.rawDataSelectionApplet = DataSelectionApplet(
self,
"Raw Data",
"Raw Data",
supportIlastik05Import=False,
batchDataGui=False)
self.labelDataSelectionApplet = DataSelectionApplet(
self,
"Label Image",
"Label Image",
supportIlastik05Import=False,
batchDataGui=False)
self.viewerApplet = LabelImageViewerApplet(self)
# Expose for shell
self._applets.append(self.rawDataSelectionApplet)
self._applets.append(self.labelDataSelectionApplet)
self._applets.append(self.viewerApplet)
def __init__(self,
shell,
headless,
workflow_cmdline_args,
project_creation_args,
appendBatchOperators=True,
*args,
**kwargs):
# Create a graph to be shared by all operators
graph = Graph()
super(AutocontextClassificationWorkflow,
self).__init__(shell,
headless,
workflow_cmdline_args,
project_creation_args,
graph=graph,
*args,
**kwargs)
self._applets = []
## Create applets
self.projectMetadataApplet = ProjectMetadataApplet()
self.dataSelectionApplet = DataSelectionApplet(
self,
"Input Data",
"Input Data",
supportIlastik05Import=True,
batchDataGui=False)
self.featureSelectionApplet = FeatureSelectionApplet(
self, "Feature Selection", "FeatureSelections")
self.pcApplet = AutocontextClassificationApplet(
self, "PixelClassification")
# Autocontext constant
opClassifyTopLevel = self.pcApplet.topLevelOperator
opClassifyTopLevel.AutocontextIterations.setValue(2)
# Expose for shell
self._applets.append(self.projectMetadataApplet)
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.featureSelectionApplet)
self._applets.append(self.pcApplet)
if appendBatchOperators:
# Create applets for batch workflow
self.batchInputApplet = DataSelectionApplet(
self,
"Batch Prediction Input Selections",
"BatchDataSelection",
supportIlastik05Import=False,
batchDataGui=True)
self.batchResultsApplet = BatchIoApplet(
self, "Batch Prediction Output Locations")
# Expose in shell
self._applets.append(self.batchInputApplet)
self._applets.append(self.batchResultsApplet)
# Connect batch workflow (NOT lane-based)
self._initBatchWorkflow()
def __init__(self,
headless,
workflow_cmdline_args,
appendBatchOperators=True,
*args,
**kwargs):
graph = kwargs['graph'] if 'graph' in kwargs else Graph()
if 'graph' in kwargs: del kwargs['graph']
super(CountingWorkflow, self).__init__(headless,
graph=graph,
*args,
**kwargs)
######################
# Interactive workflow
######################
self.projectMetadataApplet = ProjectMetadataApplet()
self.dataSelectionApplet = DataSelectionApplet(self,
"Data Selection",
"DataSelection",
batchDataGui=False,
force5d=False)
opDataSelection = self.dataSelectionApplet.topLevelOperator
opDataSelection.DatasetRoles.setValue(['Raw Data'])
self.featureSelectionApplet = FeatureSelectionApplet(
self, "Feature Selection", "FeatureSelections")
#self.pcApplet = PixelClassificationApplet(self, "PixelClassification")
self.countingApplet = CountingApplet(workflow=self)
self._applets = []
self._applets.append(self.projectMetadataApplet)
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.featureSelectionApplet)
self._applets.append(self.countingApplet)
if appendBatchOperators:
# Create applets for batch workflow
self.batchInputApplet = DataSelectionApplet(
self,
"Batch Prediction Input Selections",
"BatchDataSelection",
supportIlastik05Import=False,
batchDataGui=True)
self.batchResultsApplet = CountingBatchResultsApplet(
self, "Batch Prediction Output Locations")
# Expose in shell
self._applets.append(self.batchInputApplet)
self._applets.append(self.batchResultsApplet)
# Connect batch workflow (NOT lane-based)
self._initBatchWorkflow()
def __init__(self, shell, headless, workflow_cmdline_args,
project_creation_args, *args, **kwargs):
# Create a graph to be shared by all operators
graph = Graph()
super(LayerViewerWorkflow, self).__init__(shell,
headless,
workflow_cmdline_args,
project_creation_args,
graph=graph,
*args,
**kwargs)
self._applets = []
# Roles
# Create applets
self.dataSelectionApplet = DataSelectionApplet(self, "Input Data",
"Input Data")
self.viewerApplet = LayerViewerApplet(self)
self.dataExportApplet = DataExportApplet(self, "Data Export")
opDataExport = self.dataExportApplet.topLevelOperator
opDataExport.SelectionNames.setValue(ROLES)
opDataSelection = self.dataSelectionApplet.topLevelOperator
opDataSelection.DatasetRoles.setValue(ROLES)
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.viewerApplet)
self._applets.append(self.dataExportApplet)
self._workflow_cmdline_args = workflow_cmdline_args
def __init__(self, shell, headless, workflow_cmdline_args,
project_creation_workflow, *args, **kwargs):
# Create a graph to be shared by all operators
graph = Graph()
super(VigraWatershedWorkflow, self).__init__(shell,
headless,
workflow_cmdline_args,
project_creation_workflow,
graph=graph,
*args,
**kwargs)
self._applets = []
# Create applets
self.dataSelectionApplet = DataSelectionApplet(
self,
"Input Data",
"Input Data",
supportIlastik05Import=True,
batchDataGui=False)
self.watershedApplet = VigraWatershedViewerApplet(
self, "Watershed", "Watershed")
# Dataset inputs
opDataSelection = self.dataSelectionApplet.topLevelOperator
opDataSelection.DatasetRoles.setValue(['Raw Data'])
# Expose to shell
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.watershedApplet)
def __init__(self, carvingGraphFile):
super(CarvingWorkflow, self).__init__()
self._applets = []
graph = Graph()
self._graph = graph
## Create applets
self.projectMetadataApplet = ProjectMetadataApplet()
self.dataSelectionApplet = DataSelectionApplet(graph, "Input Data", "Input Data", supportIlastik05Import=True, batchDataGui=False)
self.carvingApplet = CarvingApplet(graph, "xxx", carvingGraphFile)
self.carvingApplet.topLevelOperator.RawData.connect( self.dataSelectionApplet.topLevelOperator.Image )
self.carvingApplet.topLevelOperator.opLabeling.LabelsAllowedFlags.connect( self.dataSelectionApplet.topLevelOperator.AllowLabels )
self.carvingApplet.gui.minLabelNumber = 2
self.carvingApplet.gui.maxLabelNumber = 2
## Access applet operators
opData = self.dataSelectionApplet.topLevelOperator
## Connect operators ##
self._applets.append(self.projectMetadataApplet)
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.carvingApplet)
# The shell needs a slot from which he can read the list of image names to switch between.
# Use an OpAttributeSelector to create a slot containing just the filename from the OpDataSelection's DatasetInfo slot.
opSelectFilename = OperatorWrapper( OpAttributeSelector, graph=graph )
opSelectFilename.InputObject.connect( opData.Dataset )
opSelectFilename.AttributeName.setValue( 'filePath' )
self._imageNameListSlot = opSelectFilename.Result
def __init__(self, headless, workflow_cmdline_args, *args, **kwargs):
# Create a graph to be shared by all operators
graph = Graph()
super(DataConversionWorkflow, self).__init__(headless,
graph=graph,
*args,
**kwargs)
self._applets = []
# Create applets
self.dataSelectionApplet = DataSelectionApplet(
self,
"Input Data",
"Input Data",
supportIlastik05Import=True,
batchDataGui=False,
force5d=False)
opDataSelection = self.dataSelectionApplet.topLevelOperator
opDataSelection.DatasetRoles.setValue(["Input Data"])
self.dataExportApplet = DataExportApplet(self, "Data Export")
opDataExport = self.dataExportApplet.topLevelOperator
opDataExport.WorkingDirectory.connect(opDataSelection.WorkingDirectory)
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.dataExportApplet)
self._workflow_cmdline_args = workflow_cmdline_args
def __init__(self, shell, headless, workflow_cmdline_args,
project_creation_args):
# Create a graph to be shared by all operators
graph = Graph()
super(DeviationFromMeanWorkflow, self).__init__(shell,
headless,
workflow_cmdline_args,
project_creation_args,
graph=graph)
self._applets = []
# Create applets
self.dataSelectionApplet = DataSelectionApplet(
self,
"Input Data",
"Input Data",
supportIlastik05Import=True,
batchDataGui=False)
self.deviationFromMeanApplet = DeviationFromMeanApplet(
self, "Deviation From Mean")
opDataSelection = self.dataSelectionApplet.topLevelOperator
opDataSelection.DatasetRoles.setValue(['Raw Data'])
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.deviationFromMeanApplet)
def __init__(self, shell, headless, workflow_cmdline_args,
project_creation_args, *args, **kwargs):
# Create a graph to be shared by all operators
graph = Graph()
super(PredictionViewerWorkflow, self).__init__(shell,
headless,
workflow_cmdline_args,
project_creation_args,
graph=graph,
*args,
**kwargs)
self._applets = []
# Applets for training (interactive) workflow
self.dataSelectionApplet = DataSelectionApplet(
self,
"Viewed Predictions",
"Viewed Predictions",
supportIlastik05Import=False,
batchDataGui=False)
self.viewerApplet = PredictionViewerApplet(self)
# Expose for shell
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.viewerApplet)
def __init__(self, shell, headless, workflow_cmdline_args,
project_creation_args, *args, **kwargs):
# Create a graph to be shared by all operators
graph = Graph()
super(FillMissingSlicesWorkflow, self).__init__(shell,
headless,
workflow_cmdline_args,
project_creation_args,
graph=graph,
*args,
**kwargs)
self._applets = []
# Create applets
self.dataSelectionApplet = DataSelectionApplet(
self,
"Input Data",
"Input Data",
supportIlastik05Import=True,
batchDataGui=False)
self.fillMissingSlicesApplet = FillMissingSlicesApplet(
self, "Fill Missing Slices", "Fill Missing Slices")
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.fillMissingSlicesApplet)
def __init__(self, shell, headless, workflow_cmdline_args,
project_creation_args, *args, **kwargs):
# Create a graph to be shared by all operators
graph = Graph()
super(LayerViewerWorkflow, self).__init__(shell,
headless,
workflow_cmdline_args,
project_creation_args,
graph=graph,
*args,
**kwargs)
self._applets = []
# Create applets
self.dataSelectionApplet = DataSelectionApplet(
self,
"Input Data",
"Input Data",
supportIlastik05Import=True,
forceAxisOrder='tzyxc')
self.viewerApplet = LayerViewerApplet(self)
self.dataExportApplet = DataExportApplet(self, "Data Export")
opDataExport = self.dataExportApplet.topLevelOperator
opDataExport.SelectionNames.setValue(['Raw Data', 'Other Data'])
opDataSelection = self.dataSelectionApplet.topLevelOperator
opDataSelection.DatasetRoles.setValue(["Raw Data", "Other Data"])
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.viewerApplet)
self._applets.append(self.dataExportApplet)
self._workflow_cmdline_args = workflow_cmdline_args
def __init__(self):
super(VigraWatershedWorkflow, self).__init__()
self._applets = []
# Create a graph to be shared by all operators
graph = Graph()
self._graph = graph
# Create applets
self.dataSelectionApplet = DataSelectionApplet(
graph,
"Input Data",
"Input Data",
supportIlastik05Import=True,
batchDataGui=False)
self.watershedApplet = VigraWatershedViewerApplet(
graph, "Watershed", "Watershed")
# Connect top-level operators
self.watershedApplet.topLevelOperator.InputImage.connect(
self.dataSelectionApplet.topLevelOperator.Image)
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.watershedApplet)
# The shell needs a slot from which he can read the list of image names to switch between.
# Use an OpAttributeSelector to create a slot containing just the filename from the OpDataSelection's DatasetInfo slot.
opSelectFilename = OperatorWrapper(OpAttributeSelector, graph=graph)
opSelectFilename.InputObject.connect(
self.dataSelectionApplet.topLevelOperator.Dataset)
opSelectFilename.AttributeName.setValue('filePath')
self._imageNameListSlot = opSelectFilename.Result
def setupInputs(self):
data_instructions = 'Use the "Raw Data" tab on the right to load your intensity image(s).'
self.dataSelectionApplet = DataSelectionApplet( self,
"Input Data",
"Input Data",
batchDataGui=False,
forceAxisOrder=None,
instructionText=data_instructions )
opData = self.dataSelectionApplet.topLevelOperator
opData.DatasetRoles.setValue(['Raw Data'])
self.featureSelectionApplet = FeatureSelectionApplet(
self,
"Feature Selection",
"FeatureSelections",
)
self.pcApplet = PixelClassificationApplet(
self, "PixelClassification")
self.thresholdingApplet = ThresholdTwoLevelsApplet(
self, "Thresholding", "ThresholdTwoLevels")
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.featureSelectionApplet)
self._applets.append(self.pcApplet)
self._applets.append(self.thresholdingApplet)
if not self._headless:
self._shell.currentAppletChanged.connect( self.handle_applet_changed )
def __init__( self, headless, workflow_cmdline_args, *args, **kwargs ):
graph = kwargs['graph'] if 'graph' in kwargs else Graph()
if 'graph' in kwargs: del kwargs['graph']
super(ChaingraphTrackingWorkflow, self).__init__(headless=headless, graph=graph, *args, **kwargs)
data_instructions = 'Use the "Raw Data" tab to load your intensity image(s).\n\n'\
'Use the "Prediction Maps" tab to load your pixel-wise probability image(s).'
## Create applets
self.dataSelectionApplet = DataSelectionApplet(self,
"Input Data",
"Input Data",
batchDataGui=False,
force5d=True,
instructionText=data_instructions,
max_lanes=1 )
opDataSelection = self.dataSelectionApplet.topLevelOperator
opDataSelection.DatasetRoles.setValue( ['Raw Data', 'Prediction Maps'] )
self.thresholdTwoLevelsApplet = ThresholdTwoLevelsApplet( self,
"Threshold and Size Filter",
"ThresholdTwoLevels" )
self.objectExtractionApplet = ObjectExtractionApplet( name="Object Feature Computation",
workflow=self, interactive=False )
self.trackingApplet = ChaingraphTrackingApplet( workflow=self )
self._applets = []
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.thresholdTwoLevelsApplet)
self._applets.append(self.objectExtractionApplet)
self._applets.append(self.trackingApplet)
def __init__(self, headless, workflow_cmdline_args, *args, **kwargs):
# Create a graph to be shared by all operators
graph = Graph()
super(LayerViewerWorkflow, self).__init__(headless, graph=graph, *args, **kwargs)
self._applets = []
# Create applets
self.dataSelectionApplet = DataSelectionApplet(self,
"Input Data",
"Input Data",
supportIlastik05Import=True,
batchDataGui=False,
force5d=True)
self.viewerApplet = LayerViewerApplet(self)
self.dataExportApplet = DataExportApplet(self, "Data Export")
opDataSelection = self.dataSelectionApplet.topLevelOperator
opDataSelection.DatasetRoles.setValue( ["Raw Data", "Other Data"] )
self._applets.append( self.dataSelectionApplet )
self._applets.append( self.viewerApplet )
self._applets.append( self.dataExportApplet )
self._workflow_cmdline_args = workflow_cmdline_args
def setupInputs(self):
data_instructions = 'Use the "Raw Data" tab on the right to load your intensity image(s).'
self.dataSelectionApplet = DataSelectionApplet( self,
"Input Data",
"Input Data",
batchDataGui=False,
forceAxisOrder=None,
instructionText=data_instructions )
opData = self.dataSelectionApplet.topLevelOperator
opData.DatasetRoles.setValue(['Raw Data'])
self.featureSelectionApplet = FeatureSelectionApplet(
self,
"Feature Selection",
"FeatureSelections",
filter_implementation=self.filter_implementation
)
self.pcApplet = PixelClassificationApplet(
self, "PixelClassification")
self.thresholdingApplet = ThresholdTwoLevelsApplet(
self, "Thresholding", "ThresholdTwoLevels")
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.featureSelectionApplet)
self._applets.append(self.pcApplet)
self._applets.append(self.thresholdingApplet)
def __init__(self, shell, headless, workflow_cmdline_args,
project_creation_args, *args, **kwargs):
# Create a graph to be shared by all operators
graph = Graph()
super(LabelingWorkflow, self).__init__(shell,
headless,
workflow_cmdline_args,
project_creation_args,
graph=graph,
*args,
**kwargs)
self._applets = []
# Create applets
self.dataSelectionApplet = DataSelectionApplet(
self,
"Input Data",
"Input Data",
supportIlastik05Import=True,
batchDataGui=False)
self.labelingSingleLaneApplet = LabelingSingleLaneApplet(
self, "Generic Labeling (single-lane)")
self.labelingMultiLaneApplet = LabelingApplet(
self, "Generic Labeling (multi-lane)")
opDataSelection = self.dataSelectionApplet.topLevelOperator
opDataSelection.DatasetRoles.setValue(["Raw Data"])
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.labelingSingleLaneApplet)
self._applets.append(self.labelingMultiLaneApplet)
def __init__(self, shell, headless, workflow_cmdline_args,
project_creation_args):
# Create a graph to be shared by all operators
graph = Graph()
super(ThresholdMaskingWorkflow, self).__init__(shell,
headless,
workflow_cmdline_args,
project_creation_args,
graph=graph)
self._applets = []
# Create applets
self.dataSelectionApplet = DataSelectionApplet(
self,
"Input Data",
"Input Data",
supportIlastik05Import=True,
batchDataGui=False)
self.thresholdMaskingApplet = ThresholdMaskingApplet(
self, "Thresholding", "Thresholding Stage 1")
opDataSelection = self.dataSelectionApplet.topLevelOperator
opDataSelection.DatasetRoles.setValue(self.ROLE_NAMES)
# Instantiate DataExport applet
self.dataExportApplet = DataExportApplet(self, "Data Export")
# Configure global DataExport settings
opDataExport = self.dataExportApplet.topLevelOperator
opDataExport.WorkingDirectory.connect(opDataSelection.WorkingDirectory)
opDataExport.SelectionNames.setValue(self.EXPORT_NAMES)
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.thresholdMaskingApplet)
self._applets.append(self.dataExportApplet)
def __init__(
self,
shell,
headless,
workflow_cmdline_args,
project_creation_args,
hintoverlayFile=None,
pmapoverlayFile=None,
*args,
**kwargs,
):
if workflow_cmdline_args:
assert False, "Not using workflow cmdline args yet."
if hintoverlayFile is not None:
assert isinstance(hintoverlayFile, str), "hintoverlayFile should be a string, not '%s'" % type(
hintoverlayFile
)
if pmapoverlayFile is not None:
assert isinstance(pmapoverlayFile, str), "pmapoverlayFile should be a string, not '%s'" % type(
pmapoverlayFile
)
graph = Graph()
super(CarvingFromPixelPredictionsWorkflow, self).__init__(
shell, headless, workflow_cmdline_args, project_creation_args, *args, graph=graph, **kwargs
)
## Create applets
self.dataSelectionApplet = DataSelectionApplet(
self, "Input Data", "Input Data", supportIlastik05Import=True, batchDataGui=False
)
opDataSelection = self.dataSelectionApplet.topLevelOperator
opDataSelection.DatasetRoles.setValue(["Raw Data"])
self.featureSelectionApplet = FeatureSelectionApplet(self, "Feature Selection", "FeatureSelections")
self.pixelClassificationApplet = PixelClassificationApplet(self, "PixelClassification")
self.carvingApplet = CarvingApplet(
workflow=self,
projectFileGroupName="carving",
hintOverlayFile=hintoverlayFile,
pmapOverlayFile=pmapoverlayFile,
)
self.preprocessingApplet = PreprocessingApplet(
workflow=self, title="Preprocessing", projectFileGroupName="carving"
)
# self.carvingApplet.topLevelOperator.MST.connect(self.preprocessingApplet.topLevelOperator.PreprocessedData)
# Expose to shell
self._applets = []
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.featureSelectionApplet)
self._applets.append(self.pixelClassificationApplet)
self._applets.append(self.preprocessingApplet)
self._applets.append(self.carvingApplet)
def __init__(self, shell, headless, workflow_cmdline_args, project_creation_args, *args, **kwargs):
# Create a graph to be shared by all operators
graph = Graph()
super(DataConversionWorkflow, self).__init__(
shell, headless, workflow_cmdline_args, project_creation_args, graph=graph, *args, **kwargs
)
self._applets = []
# Instantiate DataSelection applet
self.dataSelectionApplet = DataSelectionApplet(
self, "Input Data", "Input Data", supportIlastik05Import=True, forceAxisOrder=None
)
# Configure global DataSelection settings
role_names = ["Input Data"]
opDataSelection = self.dataSelectionApplet.topLevelOperator
opDataSelection.DatasetRoles.setValue(role_names)
# Instantiate DataExport applet
self.dataExportApplet = DataExportApplet(self, "Data Export")
# Configure global DataExport settings
opDataExport = self.dataExportApplet.topLevelOperator
opDataExport.WorkingDirectory.connect(opDataSelection.WorkingDirectory)
opDataExport.SelectionNames.setValue(["Input"])
# No special data pre/post processing necessary in this workflow,
# but this is where we'd hook it up if we needed it.
#
# self.dataExportApplet.prepare_for_entire_export = self.prepare_for_entire_export
# self.dataExportApplet.prepare_lane_for_export = self.prepare_lane_for_export
# self.dataExportApplet.post_process_lane_export = self.post_process_lane_export
# self.dataExportApplet.post_process_entire_export = self.post_process_entire_export
# Instantiate BatchProcessing applet
self.batchProcessingApplet = BatchProcessingApplet(
self, "Batch Processing", self.dataSelectionApplet, self.dataExportApplet
)
# Expose our applets in a list (for the shell to use)
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.dataExportApplet)
self._applets.append(self.batchProcessingApplet)
# Parse command-line arguments
# Command-line args are applied in onProjectLoaded(), below.
if workflow_cmdline_args:
self._data_export_args, unused_args = self.dataExportApplet.parse_known_cmdline_args(workflow_cmdline_args)
self._batch_input_args, unused_args = self.dataSelectionApplet.parse_known_cmdline_args(
unused_args, role_names
)
else:
unused_args = None
self._batch_input_args = None
self._data_export_args = None
if unused_args:
logger.warning("Unused command-line args: {}".format(unused_args))
def createDataSelectionApplet(self):
"""
Can be overridden by subclasses, if they want to use
special parameters to initialize the DataSelectionApplet.
"""
data_instructions = "Select your input data using the 'Raw Data' tab shown on the right"
return DataSelectionApplet(
self, "Input Data", "Input Data", supportIlastik05Import=True, instructionText=data_instructions
)
def __init__(self, shell, headless, workflow_cmdline_args,
project_creation_args, *args, **kwargs):
graph = kwargs['graph'] if 'graph' in kwargs else Graph()
if 'graph' in kwargs: del kwargs['graph']
super(ManualTrackingWorkflow, self).__init__(shell,
headless,
workflow_cmdline_args,
project_creation_args,
graph=graph,
*args,
**kwargs)
data_instructions = 'Use the "Raw Data" tab to load your intensity image(s).\n\n'\
'Use the "Prediction Maps" tab to load your pixel-wise probability image(s).'
## Create applets
self.dataSelectionApplet = DataSelectionApplet(
self,
"Input Data",
"Input Data",
forceAxisOrder=['txyzc'],
instructionText=data_instructions,
max_lanes=1)
opDataSelection = self.dataSelectionApplet.topLevelOperator
opDataSelection.DatasetRoles.setValue(['Raw Data', 'Prediction Maps'])
self.thresholdTwoLevelsApplet = ThresholdTwoLevelsApplet(
self, "Threshold and Size Filter", "ThresholdTwoLevels")
self.objectExtractionApplet = ObjectExtractionApplet(
name="Object Feature Computation",
workflow=self,
interactive=False)
self.trackingApplet = ManualTrackingApplet(workflow=self)
self.default_export_filename = '{dataset_dir}/{nickname}-exported_data.csv'
self.dataExportApplet = TrackingBaseDataExportApplet(
self,
"Tracking Result Export",
default_export_filename=self.default_export_filename,
)
opDataExport = self.dataExportApplet.topLevelOperator
opDataExport.SelectionNames.setValue(
['Manual Tracking', 'Object Identities'])
opDataExport.WorkingDirectory.connect(opDataSelection.WorkingDirectory)
# Extra configuration for object export table (as CSV table or HDF5 table)
opTracking = self.trackingApplet.topLevelOperator
self.dataExportApplet.set_exporting_operator(opTracking)
#self.dataExportApplet.post_process_lane_export = self.post_process_lane_export
self._applets = []
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.thresholdTwoLevelsApplet)
self._applets.append(self.objectExtractionApplet)
self._applets.append(self.trackingApplet)
self._applets.append(self.dataExportApplet)
def __init__(self, shell, headless, workflow_cmdline_args,
project_creation_args, *args, **kwargs):
super(BlockwiseObjectClassificationWorkflow,
self).__init__(shell, headless, workflow_cmdline_args,
project_creation_args, *args, **kwargs)
### INTERACTIVE ###
# Create applet
self.blockwiseObjectClassificationApplet = BlockwiseObjectClassificationApplet(
self, "Blockwise Object Classification",
"Blockwise Object Classification")
# Expose for shell
self._applets.append(self.blockwiseObjectClassificationApplet)
### BATCH ###
# Create applets for batch workflow
self.rawBatchInputApplet = DataSelectionApplet(
self,
"Raw Batch Input Selections",
"RawBatchDataSelection",
supportIlastik05Import=False,
batchDataGui=True)
# Create applets for batch workflow
self.binaryBatchInputApplet = DataSelectionApplet(
self,
"Binary Batch Input Selections",
"BinaryBatchDataSelection",
supportIlastik05Import=False,
batchDataGui=True)
self.batchResultsApplet = BlockwiseObjectClassificationBatchApplet(
self, "Batch Output Locations")
# Expose in shell
self._applets.append(self.rawBatchInputApplet)
self._applets.append(self.binaryBatchInputApplet)
self._applets.append(self.batchResultsApplet)
# Connect batch workflow (NOT lane-based)
self._initBatchWorkflow()
def createDataSelectionApplet(self):
data_instructions = "Select your input data using the 'Raw Data' tab shown on the right"
return DataSelectionApplet(
self,
"Input Data",
"Input Data",
supportIlastik05Import=True,
batchDataGui=False,
instructionText=data_instructions,
show_axis_details=self.supports_anisotropic_data)
def _createInputAndConfigApplets(self):
data_instructions = "Select your input data using the 'Raw Data' tab shown on the right"
self.dataSelectionApplet = DataSelectionApplet(
self,
"Input Data",
"Input Data",
instructionText=data_instructions)
opDataSelection = self.dataSelectionApplet.topLevelOperator
opDataSelection.DatasetRoles.setValue(self.ROLE_NAMES)
self._applets.append(self.dataSelectionApplet)
def __init__(self, headless, workflow_cmdline_args, *args, **kwargs):
# Create a graph to be shared by all operators
graph = Graph()
super(FeatureSelectionWorkflow, self).__init__( headless, graph=graph, *args, **kwargs)
self._applets = []
# Create applets
self.dataSelectionApplet = DataSelectionApplet(self, "Input Data", "Input Data", supportIlastik05Import=True, batchDataGui=False)
self.featureSelectionApplet = FeatureSelectionApplet(self, "FeatureSelection", "Feature Selection")
self._applets.append( self.dataSelectionApplet )
self._applets.append( self.featureSelectionApplet )
def createInputApplets(self):
self.dataSelectionApplet = DataSelectionApplet(
self,
"Input Data",
"Input Data",
batchDataGui=False,
forceAxisOrder=['txyzc'],
instructionText=self.data_instructions)
opData = self.dataSelectionApplet.topLevelOperator
opData.DatasetRoles.setValue(self.InputImageRoles.asDisplayNameList())
self._applets.append(self.dataSelectionApplet)
def __init__(self, shell, headless, workflow_cmdline_args,
project_creation_args, *args, **kwargs):
graph = kwargs['graph'] if 'graph' in kwargs else Graph()
if 'graph' in kwargs: del kwargs['graph']
super(ManualTrackingWorkflow, self).__init__(shell,
headless,
workflow_cmdline_args,
project_creation_args,
graph=graph,
*args,
**kwargs)
data_instructions = 'Use the "Raw Data" tab to load your intensity image(s).\n\n'\
'Use the "Prediction Maps" tab to load your pixel-wise probability image(s).'
## Create applets
self.dataSelectionApplet = DataSelectionApplet(
self,
"Input Data",
"Input Data",
batchDataGui=False,
force5d=True,
instructionText=data_instructions,
max_lanes=1)
opDataSelection = self.dataSelectionApplet.topLevelOperator
opDataSelection.DatasetRoles.setValue(['Raw Data', 'Prediction Maps'])
self.thresholdTwoLevelsApplet = ThresholdTwoLevelsApplet(
self, "Threshold and Size Filter", "ThresholdTwoLevels")
self.objectExtractionApplet = ObjectExtractionApplet(
name="Object Feature Computation",
workflow=self,
interactive=False)
self.trackingApplet = ManualTrackingApplet(workflow=self)
opTracking = self.trackingApplet.topLevelOperator
self.dataExportApplet = TrackingBaseDataExportApplet(
self, "Tracking Result Export")
self.dataExportApplet.set_exporting_operator(opTracking)
opDataExport = self.dataExportApplet.topLevelOperator
opDataExport.SelectionNames.setValue(
['Manual Tracking', 'Object Identities'])
opDataExport.WorkingDirectory.connect(opDataSelection.WorkingDirectory)
self._applets = []
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.thresholdTwoLevelsApplet)
self._applets.append(self.objectExtractionApplet)
self._applets.append(self.trackingApplet)
self._applets.append(self.dataExportApplet)
def setupInputs(self):
data_instructions = 'Use the "Raw Data" tab to load your intensity image(s).\n\n'\
'Use the "Segmentation Image" tab to load your binary mask image(s).'
self.dataSelectionApplet = DataSelectionApplet( self,
"Input Data",
"Input Data",
batchDataGui=False,
forceAxisOrder='txyzc',
instructionText=data_instructions )
opData = self.dataSelectionApplet.topLevelOperator
opData.DatasetRoles.setValue(['Raw Data', 'Segmentation Image'])
self._applets.append(self.dataSelectionApplet)
def __init__(self, headless, workflow_cmdline_args):
# Create a graph to be shared by all operators
graph = Graph()
super(ThresholdMaskingWorkflow, self).__init__(headless, graph=graph)
self._applets = []
# Create applets
self.dataSelectionApplet = DataSelectionApplet(self, "Input Data", "Input Data", supportIlastik05Import=True, batchDataGui=False)
self.thresholdMaskingApplet = ThresholdMaskingApplet(self, "Thresholding", "Thresholding Stage 1")
opDataSelection = self.dataSelectionApplet.topLevelOperator
opDataSelection.DatasetRoles.setValue( ['Raw Data'] )
self._applets.append( self.dataSelectionApplet )
self._applets.append( self.thresholdMaskingApplet )
