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, 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,
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, hintoverlayFile=None, pmapoverlayFile=None, *args, **kwargs):
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(CarvingWorkflow, self).__init__(shell, headless, workflow_cmdline_args, project_creation_args, graph=graph, *args, **kwargs)
data_instructions = "Select your input data using the 'Raw Data' tab shown on the right"
## Create applets
self.projectMetadataApplet = ProjectMetadataApplet()
self.dataSelectionApplet = DataSelectionApplet( self,
"Input Data",
"Input Data",
supportIlastik05Import=True,
batchDataGui=False,
instructionText=data_instructions,
max_lanes=1 )
opDataSelection = self.dataSelectionApplet.topLevelOperator
opDataSelection.DatasetRoles.setValue( ['Raw Data'] )
self.preprocessingApplet = PreprocessingApplet(workflow=self,
title = "Preprocessing",
projectFileGroupName="preprocessing")
self.carvingApplet = CarvingApplet(workflow=self,
projectFileGroupName="carving",
hintOverlayFile=hintoverlayFile,
pmapOverlayFile=pmapoverlayFile)
#self.carvingApplet.topLevelOperator.MST.connect(self.preprocessingApplet.topLevelOperator.PreprocessedData)
# Expose to shell
self._applets = []
self._applets.append(self.projectMetadataApplet)
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.preprocessingApplet)
self._applets.append(self.carvingApplet)
def __init__(self, headless, workflow_cmdline_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__(headless, *args, graph=graph, **kwargs)
## Create applets
self.projectMetadataApplet = ProjectMetadataApplet()
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.projectMetadataApplet)
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):
graph = kwargs['graph'] if 'graph' in kwargs else Graph()
if 'graph' in kwargs:
del kwargs['graph']
super(ObjectClassificationWorkflow, self).__init__(shell, headless, workflow_cmdline_args, project_creation_args, graph=graph, *args, **kwargs)
self.stored_pixel_classifier = None
self.stored_object_classifier = None
# Parse workflow-specific command-line args
parser = argparse.ArgumentParser()
parser.add_argument('--fillmissing', help="use 'fill missing' applet with chosen detection method", choices=['classic', 'svm', 'none'], default='none')
parser.add_argument('--filter', help="pixel feature filter implementation.", choices=['Original', 'Refactored', 'Interpolated'], default='Original')
parser.add_argument('--nobatch', help="do not append batch applets", action='store_true', default=False)
parsed_creation_args, unused_args = parser.parse_known_args(project_creation_args)
self.fillMissing = parsed_creation_args.fillmissing
self.filter_implementation = parsed_creation_args.filter
parsed_args, unused_args = parser.parse_known_args(workflow_cmdline_args)
if parsed_args.fillmissing != 'none' and parsed_creation_args.fillmissing != parsed_args.fillmissing:
logger.error( "Ignoring --fillmissing cmdline arg. Can't specify a different fillmissing setting after the project has already been created." )
if parsed_args.filter != 'Original' and parsed_creation_args.filter != parsed_args.filter:
logger.error( "Ignoring --filter cmdline arg. Can't specify a different filter setting after the project has already been created." )
self.batch = not parsed_args.nobatch
self._applets = []
self.pcApplet = None
self.projectMetadataApplet = ProjectMetadataApplet()
self._applets.append(self.projectMetadataApplet)
self.setupInputs()
if self.fillMissing != 'none':
self.fillMissingSlicesApplet = FillMissingSlicesApplet(
self, "Fill Missing Slices", "Fill Missing Slices", self.fillMissing)
self._applets.append(self.fillMissingSlicesApplet)
if isinstance(self, ObjectClassificationWorkflowPixel):
self.input_types = 'raw'
elif isinstance(self, ObjectClassificationWorkflowBinary):
self.input_types = 'raw+binary'
elif isinstance( self, ObjectClassificationWorkflowPrediction ):
self.input_types = 'raw+pmaps'
# our main applets
self.objectExtractionApplet = ObjectExtractionApplet(workflow=self, name = "Object Feature Selection")
self.objectClassificationApplet = ObjectClassificationApplet(workflow=self)
self.dataExportApplet = ObjectClassificationDataExportApplet(self, "Object Information Export")
self.dataExportApplet.set_exporting_operator(self.objectClassificationApplet.topLevelOperator)
# Customization hooks
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
opDataExport = self.dataExportApplet.topLevelOperator
opDataExport.WorkingDirectory.connect( self.dataSelectionApplet.topLevelOperator.WorkingDirectory )
# See EXPORT_SELECTION_PREDICTIONS and EXPORT_SELECTION_PROBABILITIES, above
export_selection_names = ['Object Predictions',
'Object Probabilities',
'Blockwise Object Predictions',
'Blockwise Object Probabilities']
if self.input_types == 'raw':
# Re-configure to add the pixel probabilities option
# See EXPORT_SELECTION_PIXEL_PROBABILITIES, above
export_selection_names.append( 'Pixel Probabilities' )
opDataExport.SelectionNames.setValue( export_selection_names )
self._batch_export_args = None
self._batch_input_args = None
self._export_args = None
self.batchProcessingApplet = None
if self.batch:
self.batchProcessingApplet = BatchProcessingApplet(self,
"Batch Processing",
self.dataSelectionApplet,
self.dataExportApplet)
if unused_args:
# Additional export args (specific to the object classification workflow)
export_arg_parser = argparse.ArgumentParser()
export_arg_parser.add_argument( "--table_filename", help="The location to export the object feature/prediction CSV file.", required=False )
export_arg_parser.add_argument( "--export_object_prediction_img", action="store_true" )
export_arg_parser.add_argument( "--export_object_probability_img", action="store_true" )
# TODO: Support this, too, someday?
#export_arg_parser.add_argument( "--export_object_label_img", action="store_true" )
if self.input_types == 'raw':
export_arg_parser.add_argument( "--export_pixel_probability_img", action="store_true" )
self._export_args, unused_args = export_arg_parser.parse_known_args(unused_args)
self._export_args.export_pixel_probability_img = self._export_args.export_pixel_probability_img or None
# We parse the export setting args first. All remaining args are considered input files by the input applet.
self._batch_export_args, unused_args = self.dataExportApplet.parse_known_cmdline_args( unused_args )
self._batch_input_args, unused_args = self.batchProcessingApplet.parse_known_cmdline_args( unused_args )
# For backwards compatibility, translate these special args into the standard syntax
if self._export_args.export_object_prediction_img:
self._batch_input_args.export_source = "Object Predictions"
if self._export_args.export_object_probability_img:
self._batch_input_args.export_source = "Object Probabilities"
if self._export_args.export_pixel_probability_img:
self._batch_input_args.export_source = "Pixel Probabilities"
self.blockwiseObjectClassificationApplet = BlockwiseObjectClassificationApplet(
self, "Blockwise Object Classification", "Blockwise Object Classification")
self._applets.append(self.objectExtractionApplet)
self._applets.append(self.objectClassificationApplet)
self._applets.append(self.dataExportApplet)
if self.batchProcessingApplet:
self._applets.append(self.batchProcessingApplet)
self._applets.append(self.blockwiseObjectClassificationApplet)
if unused_args:
logger.warn("Unused command-line args: {}".format( unused_args ))
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( PixelClassificationWorkflow, self ).__init__( shell, headless, workflow_cmdline_args, project_creation_args, graph=graph, *args, **kwargs )
self.stored_classifer = None
self._applets = []
self._workflow_cmdline_args = workflow_cmdline_args
# Parse workflow-specific command-line args
parser = argparse.ArgumentParser()
parser.add_argument('--filter', help="pixel feature filter implementation.", choices=['Original', 'Refactored', 'Interpolated'], default='Original')
parser.add_argument('--print-labels-by-slice', help="Print the number of labels for each Z-slice of each image.", action="store_true")
parser.add_argument('--label-search-value', help="If provided, only this value is considered when using --print-labels-by-slice", default=0, type=int)
parser.add_argument('--generate-random-labels', help="Add random labels to the project file.", action="store_true")
parser.add_argument('--random-label-value', help="The label value to use injecting random labels", default=1, type=int)
parser.add_argument('--random-label-count', help="The number of random labels to inject via --generate-random-labels", default=2000, type=int)
parser.add_argument('--retrain', help="Re-train the classifier based on labels stored in project file, and re-save.", action="store_true")
parser.add_argument('--tree-count', help='Number of trees for Vigra RF classifier.', type=int)
parser.add_argument('--variable-importance-path', help='Location of variable-importance table.', type=str)
parser.add_argument('--label-proportion', help='Proportion of feature-pixels used to train the classifier.', type=float)
# Parse the creation args: These were saved to the project file when this project was first created.
parsed_creation_args, unused_args = parser.parse_known_args(project_creation_args)
self.filter_implementation = parsed_creation_args.filter
# Parse the cmdline args for the current session.
parsed_args, unused_args = parser.parse_known_args(workflow_cmdline_args)
self.print_labels_by_slice = parsed_args.print_labels_by_slice
self.label_search_value = parsed_args.label_search_value
self.generate_random_labels = parsed_args.generate_random_labels
self.random_label_value = parsed_args.random_label_value
self.random_label_count = parsed_args.random_label_count
self.retrain = parsed_args.retrain
self.tree_count = parsed_args.tree_count
self.variable_importance_path = parsed_args.variable_importance_path
self.label_proportion = parsed_args.label_proportion
if parsed_args.filter and parsed_args.filter != parsed_creation_args.filter:
logger.error("Ignoring new --filter setting. Filter implementation cannot be changed after initial project creation.")
data_instructions = "Select your input data using the 'Raw Data' tab shown on the right.\n\n"\
"Power users: Optionally use the 'Prediction Mask' tab to supply a binary image that tells ilastik where it should avoid computations you don't need."
# Applets for training (interactive) workflow
self.projectMetadataApplet = ProjectMetadataApplet()
self.dataSelectionApplet = self.createDataSelectionApplet()
opDataSelection = self.dataSelectionApplet.topLevelOperator
# see role constants, above
opDataSelection.DatasetRoles.setValue( PixelClassificationWorkflow.ROLE_NAMES )
self.featureSelectionApplet = self.createFeatureSelectionApplet()
self.pcApplet = self.createPixelClassificationApplet()
opClassify = self.pcApplet.topLevelOperator
self.dataExportApplet = PixelClassificationDataExportApplet(self, "Prediction Export")
opDataExport = self.dataExportApplet.topLevelOperator
opDataExport.PmapColors.connect( opClassify.PmapColors )
opDataExport.LabelNames.connect( opClassify.LabelNames )
opDataExport.WorkingDirectory.connect( opDataSelection.WorkingDirectory )
opDataExport.SelectionNames.setValue( self.EXPORT_NAMES )
# Expose for shell
self._applets.append(self.projectMetadataApplet)
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.featureSelectionApplet)
self._applets.append(self.pcApplet)
self._applets.append(self.dataExportApplet)
self.dataExportApplet.prepare_for_entire_export = self.prepare_for_entire_export
self.dataExportApplet.post_process_entire_export = self.post_process_entire_export
self.batchProcessingApplet = BatchProcessingApplet(self,
"Batch Processing",
self.dataSelectionApplet,
self.dataExportApplet)
self._applets.append(self.batchProcessingApplet)
if unused_args:
# We parse the export setting args first. All remaining args are considered input files by the input applet.
self._batch_export_args, unused_args = self.dataExportApplet.parse_known_cmdline_args( unused_args )
self._batch_input_args, unused_args = self.batchProcessingApplet.parse_known_cmdline_args( unused_args )
else:
self._batch_input_args = None
self._batch_export_args = None
if unused_args:
logger.warn("Unused command-line args: {}".format( unused_args ))
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(PixelClassificationWorkflow,
self).__init__(shell,
headless,
workflow_cmdline_args,
project_creation_args,
graph=graph,
*args,
**kwargs)
self._applets = []
self._workflow_cmdline_args = workflow_cmdline_args
data_instructions = "Select your input data using the 'Raw Data' tab shown on the right"
# Parse workflow-specific command-line args
parser = argparse.ArgumentParser()
parser.add_argument('--filter',
help="pixel feature filter implementation.",
choices=['Original', 'Refactored', 'Interpolated'],
default='Original')
parser.add_argument(
'--print-labels-by-slice',
help="Print the number of labels for each Z-slice of each image.",
action="store_true")
parser.add_argument(
'--label-search-value',
help=
"If provided, only this value is considered when using --print-labels-by-slice",
default=0,
type=int)
parser.add_argument('--generate-random-labels',
help="Add random labels to the project file.",
action="store_true")
parser.add_argument(
'--random-label-value',
help="The label value to use injecting random labels",
default=1,
type=int)
parser.add_argument(
'--random-label-count',
help=
"The number of random labels to inject via --generate-random-labels",
default=2000,
type=int)
parser.add_argument(
'--retrain',
help=
"Re-train the classifier based on labels stored in project file, and re-save.",
action="store_true")
# Parse the creation args: These were saved to the project file when this project was first created.
parsed_creation_args, unused_args = parser.parse_known_args(
project_creation_args)
self.filter_implementation = parsed_creation_args.filter
# Parse the cmdline args for the current session.
parsed_args, unused_args = parser.parse_known_args(
workflow_cmdline_args)
self.print_labels_by_slice = parsed_args.print_labels_by_slice
self.label_search_value = parsed_args.label_search_value
self.generate_random_labels = parsed_args.generate_random_labels
self.random_label_value = parsed_args.random_label_value
self.random_label_count = parsed_args.random_label_count
self.retrain = parsed_args.retrain
if parsed_args.filter and parsed_args.filter != parsed_creation_args.filter:
logger.error(
"Ignoring new --filter setting. Filter implementation cannot be changed after initial project creation."
)
# Applets for training (interactive) workflow
self.projectMetadataApplet = ProjectMetadataApplet()
self.dataSelectionApplet = DataSelectionApplet(
self,
"Input Data",
"Input Data",
supportIlastik05Import=True,
batchDataGui=False,
instructionText=data_instructions)
opDataSelection = self.dataSelectionApplet.topLevelOperator
if ilastik_config.getboolean('ilastik', 'debug'):
# see role constants, above
role_names = ['Raw Data', 'Prediction Mask']
opDataSelection.DatasetRoles.setValue(role_names)
else:
role_names = ['Raw Data']
opDataSelection.DatasetRoles.setValue(role_names)
self.featureSelectionApplet = FeatureSelectionApplet(
self, "Feature Selection", "FeatureSelections",
self.filter_implementation)
self.pcApplet = PixelClassificationApplet(self, "PixelClassification")
opClassify = self.pcApplet.topLevelOperator
self.dataExportApplet = PixelClassificationDataExportApplet(
self, "Prediction Export")
opDataExport = self.dataExportApplet.topLevelOperator
opDataExport.PmapColors.connect(opClassify.PmapColors)
opDataExport.LabelNames.connect(opClassify.LabelNames)
opDataExport.WorkingDirectory.connect(opDataSelection.WorkingDirectory)
opDataExport.SelectionNames.setValue(self.EXPORT_NAMES)
# Expose for shell
self._applets.append(self.projectMetadataApplet)
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.featureSelectionApplet)
self._applets.append(self.pcApplet)
self._applets.append(self.dataExportApplet)
self._batch_input_args = None
self._batch_export_args = None
self.batchInputApplet = None
self.batchResultsApplet = None
if appendBatchOperators:
# Create applets for batch workflow
self.batchInputApplet = DataSelectionApplet(
self,
"Batch Prediction Input Selections",
"Batch Inputs",
supportIlastik05Import=False,
batchDataGui=True)
self.batchResultsApplet = PixelClassificationDataExportApplet(
self, "Batch Prediction Output Locations", isBatch=True)
# Expose in shell
self._applets.append(self.batchInputApplet)
self._applets.append(self.batchResultsApplet)
# Connect batch workflow (NOT lane-based)
self._initBatchWorkflow()
if unused_args:
# We parse the export setting args first. All remaining args are considered input files by the input applet.
self._batch_export_args, unused_args = self.batchResultsApplet.parse_known_cmdline_args(
unused_args)
self._batch_input_args, unused_args = self.batchInputApplet.parse_known_cmdline_args(
unused_args)
if unused_args:
logger.warn("Unused command-line args: {}".format(unused_args))
def __init__(self, shell, headless, workflow_cmdline_args, project_creation_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__( shell, headless, workflow_cmdline_args, project_creation_args, graph=graph, *args, **kwargs )
# Parse workflow-specific command-line args
parser = argparse.ArgumentParser()
parser.add_argument("--csv-export-file", help="Instead of exporting prediction density images, export total counts to the given csv path.")
self.parsed_counting_workflow_args, unused_args = parser.parse_known_args(workflow_cmdline_args)
######################
# Interactive workflow
######################
self.projectMetadataApplet = ProjectMetadataApplet()
self.dataSelectionApplet = DataSelectionApplet(self,
"Input Data",
"Input Data",
batchDataGui=False,
force5d=False
)
opDataSelection = self.dataSelectionApplet.topLevelOperator
role_names = ['Raw Data']
opDataSelection.DatasetRoles.setValue( role_names )
self.featureSelectionApplet = FeatureSelectionApplet(self,
"Feature Selection",
"FeatureSelections")
#self.pcApplet = PixelClassificationApplet(self, "PixelClassification")
self.countingApplet = CountingApplet(workflow=self)
opCounting = self.countingApplet.topLevelOperator
self.dataExportApplet = CountingDataExportApplet(self, "Density Export", opCounting)
opDataExport = self.dataExportApplet.topLevelOperator
opDataExport.PmapColors.connect(opCounting.PmapColors)
opDataExport.LabelNames.connect(opCounting.LabelNames)
opDataExport.UpperBound.connect(opCounting.UpperBound)
opDataExport.WorkingDirectory.connect(opDataSelection.WorkingDirectory)
opDataExport.SelectionNames.setValue( ['Probabilities'] )
self._applets = []
self._applets.append(self.projectMetadataApplet)
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.featureSelectionApplet)
self._applets.append(self.countingApplet)
self._applets.append(self.dataExportApplet)
self._batch_input_args = None
self._batch_export_args = None
self.batchInputApplet = None
self.batchResultsApplet = None
if appendBatchOperators:
# Connect batch workflow (NOT lane-based)
self._initBatchWorkflow()
if unused_args:
# We parse the export setting args first.
# All remaining args are considered input files by the input applet.
self._batch_export_args, unused_args = self.batchResultsApplet.parse_known_cmdline_args( unused_args )
self._batch_input_args, unused_args = self.batchInputApplet.parse_known_cmdline_args( unused_args, role_names )
def __init__(self,
shell,
headless,
workflow_cmdline_args,
project_creation_args,
hintoverlayFile=None,
pmapoverlayFile=None,
*args,
**kwargs):
graph = Graph()
super(SplitBodyCarvingWorkflow, self).__init__(shell,
headless,
workflow_cmdline_args,
project_creation_args,
*args,
graph=graph,
**kwargs)
## Create applets
self.projectMetadataApplet = ProjectMetadataApplet()
self.dataSelectionApplet = DataSelectionApplet(
self,
"Input Data",
"Input Data",
supportIlastik05Import=True,
batchDataGui=False)
opDataSelection = self.dataSelectionApplet.topLevelOperator
opDataSelection.DatasetRoles.setValue(
['Raw Data', 'Pixel Probabilities', 'Raveler Labels'])
self.preprocessingApplet = PreprocessingApplet(
workflow=self,
title="Preprocessing",
projectFileGroupName="preprocessing")
self.splitBodyCarvingApplet = SplitBodyCarvingApplet(
workflow=self, projectFileGroupName="carving")
self.splitBodyPostprocessingApplet = SplitBodyPostprocessingApplet(
workflow=self)
self.splitBodySupervoxelExportApplet = SplitBodySupervoxelExportApplet(
workflow=self)
# Expose to shell
self._applets = []
self._applets.append(self.projectMetadataApplet)
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.preprocessingApplet)
self._applets.append(self.splitBodyCarvingApplet)
self._applets.append(self.splitBodyPostprocessingApplet)
self._applets.append(self.splitBodySupervoxelExportApplet)
self._split_tool_params = None
if workflow_cmdline_args:
arg_parser = argparse.ArgumentParser(
description=
"Specify parameters for the split-body carving workflow")
arg_parser.add_argument('--split_tool_param_file', required=False)
parsed_args, unused_args = arg_parser.parse_known_args(
workflow_cmdline_args)
if unused_args:
logger.warn("Unused command-line args: {}".format(unused_args))
if parsed_args.split_tool_param_file is None:
logger.warn("Missing cmd-line arg: --split_tool_param_file")
else:
logger.debug("Parsing split tool parameters: {}".format(
parsed_args.split_tool_param_file))
json_parser = JsonConfigParser(SplitToolParamsSchema)
self._split_tool_params = json_parser.parseConfigFile(
parsed_args.split_tool_param_file)
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(CountingWorkflow, self).__init__(shell,
headless,
workflow_cmdline_args,
project_creation_args,
graph=graph,
*args,
**kwargs)
self.stored_classifier = None
# Parse workflow-specific command-line args
parser = argparse.ArgumentParser()
parser.add_argument(
"--csv-export-file",
help=
"Instead of exporting prediction density images, export total counts to the given csv path."
)
self.parsed_counting_workflow_args, unused_args = parser.parse_known_args(
workflow_cmdline_args)
######################
# Interactive workflow
######################
self.projectMetadataApplet = ProjectMetadataApplet()
self.dataSelectionApplet = DataSelectionApplet(self, "Input Data",
"Input Data")
opDataSelection = self.dataSelectionApplet.topLevelOperator
role_names = ['Raw Data']
opDataSelection.DatasetRoles.setValue(role_names)
self.featureSelectionApplet = FeatureSelectionApplet(
self, "Feature Selection", "FeatureSelections")
self.countingApplet = CountingApplet(workflow=self)
opCounting = self.countingApplet.topLevelOperator
self.dataExportApplet = CountingDataExportApplet(
self, "Density Export", opCounting)
# Customization hooks
self.dataExportApplet.prepare_for_entire_export = self.prepare_for_entire_export
self.dataExportApplet.post_process_lane_export = self.post_process_lane_export
self.dataExportApplet.post_process_entire_export = self.post_process_entire_export
opDataExport = self.dataExportApplet.topLevelOperator
opDataExport.PmapColors.connect(opCounting.PmapColors)
opDataExport.LabelNames.connect(opCounting.LabelNames)
opDataExport.UpperBound.connect(opCounting.UpperBound)
opDataExport.WorkingDirectory.connect(opDataSelection.WorkingDirectory)
opDataExport.SelectionNames.setValue(['Probabilities'])
self._applets = []
self._applets.append(self.projectMetadataApplet)
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.featureSelectionApplet)
self._applets.append(self.countingApplet)
self._applets.append(self.dataExportApplet)
self.batchProcessingApplet = BatchProcessingApplet(
self, "Batch Processing", self.dataSelectionApplet,
self.dataExportApplet)
self._applets.append(self.batchProcessingApplet)
if unused_args:
# We parse the export setting args first. All remaining args are considered input files by the input applet.
self._batch_export_args, unused_args = self.dataExportApplet.parse_known_cmdline_args(
unused_args)
self._batch_input_args, unused_args = self.batchProcessingApplet.parse_known_cmdline_args(
unused_args)
else:
self._batch_input_args = None
self._batch_export_args = None
if unused_args:
logger.warn("Unused command-line args: {}".format(unused_args))
def __init__(self):
super(PixelClassificationWorkflow, self).__init__()
self._applets = []
# Create a graph to be shared by all operators
graph = Graph()
self._graph = graph
######################
# Interactive workflow
######################
## Create applets
self.projectMetadataApplet = ProjectMetadataApplet()
self.dataSelectionApplet = DataSelectionApplet(
graph,
"Input Data",
"Input Data",
supportIlastik05Import=True,
batchDataGui=False)
self.featureSelectionApplet = FeatureSelectionApplet(
graph, "Feature Selection", "FeatureSelections")
self.pcApplet = PixelClassificationApplet(graph, "PixelClassification")
## Access applet operators
opData = self.dataSelectionApplet.topLevelOperator
opTrainingFeatures = self.featureSelectionApplet.topLevelOperator
opClassify = self.pcApplet.topLevelOperator
## Connect operators ##
# Input Image -> Feature Op
# and -> Classification Op (for display)
opTrainingFeatures.InputImage.connect(opData.Image)
opClassify.InputImages.connect(opData.Image)
# Feature Images -> Classification Op (for training, prediction)
opClassify.FeatureImages.connect(opTrainingFeatures.OutputImage)
opClassify.CachedFeatureImages.connect(
opTrainingFeatures.CachedOutputImage)
# Training flags -> Classification Op (for GUI restrictions)
opClassify.LabelsAllowedFlags.connect(opData.AllowLabels)
######################
# Batch workflow
######################
## Create applets
self.batchInputApplet = DataSelectionApplet(
graph,
"Batch Inputs",
"BatchDataSelection",
supportIlastik05Import=False,
batchDataGui=True)
self.batchResultsApplet = BatchIoApplet(graph, "Batch Results")
## Access applet operators
opBatchInputs = self.batchInputApplet.topLevelOperator
opBatchInputs.name = 'opBatchInputs'
opBatchResults = self.batchResultsApplet.topLevelOperator
## Create additional batch workflow operators
opBatchFeatures = OperatorWrapper(OpFeatureSelection,
graph=graph,
promotedSlotNames=['InputImage'])
opBatchFeatures.name = "opBatchFeatures"
opBatchPredictor = OperatorWrapper(OpPredictRandomForest,
graph=graph,
promotedSlotNames=['Image'])
opBatchPredictor.name = "opBatchPredictor"
opSelectBatchDatasetPath = OperatorWrapper(OpAttributeSelector,
graph=graph)
## Connect Operators ##
# Provide dataset paths from data selection applet to the batch export applet via an attribute selector
opSelectBatchDatasetPath.InputObject.connect(opBatchInputs.Dataset)
opSelectBatchDatasetPath.AttributeName.setValue('filePath')
opBatchResults.DatasetPath.connect(opSelectBatchDatasetPath.Result)
# Connect (clone) the feature operator inputs from
# the interactive workflow's features operator (which gets them from the GUI)
opBatchFeatures.Scales.connect(opTrainingFeatures.Scales)
opBatchFeatures.FeatureIds.connect(opTrainingFeatures.FeatureIds)
opBatchFeatures.SelectionMatrix.connect(
opTrainingFeatures.SelectionMatrix)
# Classifier and LabelsCount are provided by the interactive workflow
opBatchPredictor.Classifier.connect(opClassify.Classifier)
opBatchPredictor.LabelsCount.connect(opClassify.MaxLabelValue)
# Connect Image pathway:
# Input Image -> Features Op -> Prediction Op -> Export
opBatchFeatures.InputImage.connect(opBatchInputs.Image)
opBatchPredictor.Image.connect(opBatchFeatures.OutputImage)
opBatchResults.ImageToExport.connect(opBatchPredictor.PMaps)
self._applets.append(self.projectMetadataApplet)
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.featureSelectionApplet)
self._applets.append(self.pcApplet)
self._applets.append(self.batchInputApplet)
self._applets.append(self.batchResultsApplet)
# 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,
shell,
headless,
workflow_cmdline_args,
project_creation_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__(shell,
headless,
workflow_cmdline_args,
project_creation_args,
graph=graph,
*args,
**kwargs)
######################
# Interactive workflow
######################
self.projectMetadataApplet = ProjectMetadataApplet()
self.dataSelectionApplet = DataSelectionApplet(self,
"Input Data",
"Input Data",
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)
opCounting = self.countingApplet.topLevelOperator
self.dataExportApplet = CountingDataExportApplet(
self, "Density Export")
opDataExport = self.dataExportApplet.topLevelOperator
opDataExport.PmapColors.connect(opCounting.PmapColors)
opDataExport.LabelNames.connect(opCounting.LabelNames)
opDataExport.UpperBound.connect(opCounting.UpperBound)
opDataExport.WorkingDirectory.connect(opDataSelection.WorkingDirectory)
opDataExport.SelectionNames.setValue(['Probabilities'])
self._applets = []
self._applets.append(self.projectMetadataApplet)
self._applets.append(self.dataSelectionApplet)
self._applets.append(self.featureSelectionApplet)
self._applets.append(self.countingApplet)
self._applets.append(self.dataExportApplet)
if appendBatchOperators:
# Create applets for batch workflow
self.batchInputApplet = DataSelectionApplet(
self,
"Batch Prediction Input Selections",
"BatchDataSelection",
supportIlastik05Import=False,
batchDataGui=True)
self.batchResultsApplet = CountingDataExportApplet(
self, "Batch Prediction Output Locations", isBatch=True)
# Expose in shell
self._applets.append(self.batchInputApplet)
self._applets.append(self.batchResultsApplet)
# Connect batch workflow (NOT lane-based)
self._initBatchWorkflow()