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(StructuredTrackingWorkflowBase, 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'
if self.fromBinary:
data_instructions += 'Use the "Binary Image" tab to load your segmentation image(s).'
else:
data_instructions += '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,
forceAxisOrder=['txyzc'],
instructionText=data_instructions,
max_lanes=1)
opDataSelection = self.dataSelectionApplet.topLevelOperator
if self.fromBinary:
opDataSelection.DatasetRoles.setValue( ['Raw Data', 'Binary Image'] )
else:
opDataSelection.DatasetRoles.setValue( ['Raw Data', 'Prediction Maps'] )
if not self.fromBinary:
self.thresholdTwoLevelsApplet = ThresholdTwoLevelsApplet( self,"Threshold and Size Filter","ThresholdTwoLevels" )
self.divisionDetectionApplet = ObjectClassificationApplet(workflow=self,
name="Division Detection (optional)",
projectFileGroupName="DivisionDetection",
selectedFeatures=configConservation.selectedFeaturesDiv)
self.cellClassificationApplet = ObjectClassificationApplet(workflow=self,
name="Object Count Classification",
projectFileGroupName="CountClassification",
selectedFeatures=configConservation.selectedFeaturesObjectCount)
self.trackingFeatureExtractionApplet = TrackingFeatureExtractionApplet(name="Object Feature Computation",workflow=self, interactive=False)
self.objectExtractionApplet = ObjectExtractionApplet(name="Object Feature Computation",workflow=self, interactive=False)
self.annotationsApplet = AnnotationsApplet( name="Training", workflow=self )
opAnnotations = self.annotationsApplet.topLevelOperator
self.trackingApplet = StructuredTrackingApplet( name="Tracking - Structured Learning", workflow=self )
opStructuredTracking = self.trackingApplet.topLevelOperator
if SOLVER=="CPLEX" or SOLVER=="GUROBI":
self._solver="ILP"
elif SOLVER=="DPCT":
self._solver="Flow-based"
else:
self._solver=None
opStructuredTracking._solver = self._solver
self.default_tracking_export_filename = '{dataset_dir}/{nickname}-tracking_exported_data.csv'
self.dataExportTrackingApplet = TrackingBaseDataExportApplet(self, "Tracking Result Export",default_export_filename=self.default_tracking_export_filename)
opDataExportTracking = self.dataExportTrackingApplet.topLevelOperator
opDataExportTracking.SelectionNames.setValue( ['Tracking-Result', 'Merger-Result', 'Object-Identities'] )
opDataExportTracking.WorkingDirectory.connect( opDataSelection.WorkingDirectory )
self.dataExportTrackingApplet.set_exporting_operator(opStructuredTracking)
self.dataExportTrackingApplet.prepare_lane_for_export = self.prepare_lane_for_export
self.dataExportTrackingApplet.post_process_lane_export = self.post_process_lane_export
# configure export settings
settings = {'file path': self.default_tracking_export_filename, 'compression': {}, 'file type': 'h5'}
selected_features = ['Count', 'RegionCenter', 'RegionRadii', 'RegionAxes']
opStructuredTracking.ExportSettings.setValue( (settings, selected_features) )
self._applets = []
self._applets.append(self.dataSelectionApplet)
if not self.fromBinary:
self._applets.append(self.thresholdTwoLevelsApplet)
self._applets.append(self.trackingFeatureExtractionApplet)
self._applets.append(self.divisionDetectionApplet)
self.batchProcessingApplet = BatchProcessingApplet(self, "Batch Processing", self.dataSelectionApplet, self.dataExportTrackingApplet)
self._applets.append(self.cellClassificationApplet)
self._applets.append(self.objectExtractionApplet)
self._applets.append(self.annotationsApplet)
self._applets.append(self.trackingApplet)
self._applets.append(self.dataExportTrackingApplet)
if self.divisionDetectionApplet:
opDivDetection = self.divisionDetectionApplet.topLevelOperator
opDivDetection.SelectedFeatures.setValue(configConservation.selectedFeaturesDiv)
opDivDetection.LabelNames.setValue(['Not Dividing', 'Dividing'])
opDivDetection.AllowDeleteLabels.setValue(False)
opDivDetection.AllowAddLabel.setValue(False)
opDivDetection.EnableLabelTransfer.setValue(False)
opCellClassification = self.cellClassificationApplet.topLevelOperator
opCellClassification.SelectedFeatures.setValue(configConservation.selectedFeaturesObjectCount )
opCellClassification.SuggestedLabelNames.setValue( ['False Detection',] + [str(1) + ' Object'] + [str(i) + ' Objects' for i in range(2,10) ] )
opCellClassification.AllowDeleteLastLabelOnly.setValue(True)
opCellClassification.EnableLabelTransfer.setValue(False)
if workflow_cmdline_args:
if '--testFullAnnotations' in workflow_cmdline_args:
self.testFullAnnotations = True
else:
self.testFullAnnotations = False
self._data_export_args, unused_args = self.dataExportTrackingApplet.parse_known_cmdline_args( workflow_cmdline_args )
self._batch_input_args, unused_args = self.batchProcessingApplet.parse_known_cmdline_args( workflow_cmdline_args )
else:
unused_args = None
self._data_export_args = None
self._batch_input_args = None
self.testFullAnnotations = False
if unused_args:
logger.warning("Unused command-line args: {}".format( unused_args ))
def __init__(self, shell, headless, workflow_cmdline_args, *args,
**kwargs):
graph = kwargs['graph'] if 'graph' in kwargs else Graph()
if 'graph' in kwargs: del kwargs['graph']
# if 'withOptTrans' in kwargs:
# self.withOptTrans = kwargs['withOptTrans']
# if 'fromBinary' in kwargs:
# self.fromBinary = kwargs['fromBinary']
super(ConservationTrackingWorkflowBase, self).__init__(shell,
headless,
graph=graph,
*args,
**kwargs)
data_instructions = 'Use the "Raw Data" tab to load your intensity image(s).\n\n'
if self.fromBinary:
data_instructions += 'Use the "Binary Image" tab to load your segmentation image(s).'
else:
data_instructions += '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
if self.fromBinary:
opDataSelection.DatasetRoles.setValue(['Raw Data', 'Binary Image'])
else:
opDataSelection.DatasetRoles.setValue(
['Raw Data', 'Prediction Maps'])
if not self.fromBinary:
self.thresholdTwoLevelsApplet = ThresholdTwoLevelsApplet(
self, "Threshold and Size Filter", "ThresholdTwoLevels")
if self.withOptTrans:
self.opticalTranslationApplet = OpticalTranslationApplet(
workflow=self)
self.objectExtractionApplet = TrackingFeatureExtractionApplet(
workflow=self,
interactive=False,
name="Object Feature Computation")
self.divisionDetectionApplet = ObjectClassificationApplet(
workflow=self,
name="Division Detection (optional)",
projectFileGroupName="DivisionDetection")
self.cellClassificationApplet = ObjectClassificationApplet(
workflow=self,
name="Object Count Classification (optional)",
projectFileGroupName="CountClassification")
self.trackingApplet = ConservationTrackingApplet(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(
['Tracking Result', 'Merger Result', 'Object Identities'])
opDataExport.WorkingDirectory.connect(opDataSelection.WorkingDirectory)
self._applets = []
self._applets.append(self.dataSelectionApplet)
if not self.fromBinary:
self._applets.append(self.thresholdTwoLevelsApplet)
if self.withOptTrans:
self._applets.append(self.opticalTranslationApplet)
self._applets.append(self.objectExtractionApplet)
self._applets.append(self.divisionDetectionApplet)
self._applets.append(self.cellClassificationApplet)
self._applets.append(self.trackingApplet)
self._applets.append(self.dataExportApplet)
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"]
# if 'withOptTrans' in kwargs:
# self.withOptTrans = kwargs['withOptTrans']
# if 'fromBinary' in kwargs:
# self.fromBinary = kwargs['fromBinary']
super(ConservationTrackingWorkflowBase,
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'
if self.fromBinary:
data_instructions += 'Use the "Binary Image" tab to load your segmentation image(s).'
else:
data_instructions += 'Use the "Prediction Maps" tab to load your pixel-wise probability image(s).'
# Variables to store division and cell classifiers to prevent retraining every-time batch processing runs
self.stored_division_classifier = None
self.stored_cell_classifier = None
## Create applets
self.dataSelectionApplet = DataSelectionApplet(
self,
"Input Data",
"Input Data",
forceAxisOrder=["txyzc"],
instructionText=data_instructions,
max_lanes=None,
)
opDataSelection = self.dataSelectionApplet.topLevelOperator
if self.fromBinary:
opDataSelection.DatasetRoles.setValue(
["Raw Data", "Segmentation Image"])
else:
opDataSelection.DatasetRoles.setValue(
["Raw Data", "Prediction Maps"])
if not self.fromBinary:
self.thresholdTwoLevelsApplet = ThresholdTwoLevelsApplet(
self, "Threshold and Size Filter", "ThresholdTwoLevels")
self.objectExtractionApplet = TrackingFeatureExtractionApplet(
workflow=self,
interactive=False,
name="Object Feature Computation")
opObjectExtraction = self.objectExtractionApplet.topLevelOperator
self.divisionDetectionApplet = self._createDivisionDetectionApplet(
configConservation.selectedFeaturesDiv) # Might be None
if self.divisionDetectionApplet:
feature_dict_division = {}
feature_dict_division[config.features_division_name] = {
name: {}
for name in config.division_features
}
opObjectExtraction.FeatureNamesDivision.setValue(
feature_dict_division)
selected_features_div = {}
for plugin_name in list(config.selected_features_division.keys()):
selected_features_div[plugin_name] = {
name: {}
for name in config.selected_features_division[plugin_name]
}
# FIXME: do not hard code this
for name in [
"SquaredDistances_" + str(i)
for i in range(config.n_best_successors)
]:
selected_features_div[config.features_division_name][name] = {}
opDivisionDetection = self.divisionDetectionApplet.topLevelOperator
opDivisionDetection.SelectedFeatures.setValue(
configConservation.selectedFeaturesDiv)
opDivisionDetection.LabelNames.setValue(
["Not Dividing", "Dividing"])
opDivisionDetection.AllowDeleteLabels.setValue(False)
opDivisionDetection.AllowAddLabel.setValue(False)
opDivisionDetection.EnableLabelTransfer.setValue(False)
self.cellClassificationApplet = ObjectClassificationApplet(
workflow=self,
name="Object Count Classification",
projectFileGroupName="CountClassification",
selectedFeatures=configConservation.selectedFeaturesObjectCount,
)
selected_features_objectcount = {}
for plugin_name in list(config.selected_features_objectcount.keys()):
selected_features_objectcount[plugin_name] = {
name: {}
for name in config.selected_features_objectcount[plugin_name]
}
opCellClassification = self.cellClassificationApplet.topLevelOperator
opCellClassification.SelectedFeatures.setValue(
configConservation.selectedFeaturesObjectCount)
opCellClassification.SuggestedLabelNames.setValue(
["False Detection"] + [str(1) + " Object"] +
[str(i) + " Objects" for i in range(2, 10)])
opCellClassification.AllowDeleteLastLabelOnly.setValue(True)
opCellClassification.EnableLabelTransfer.setValue(False)
self.trackingApplet = ConservationTrackingApplet(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,
pluginExportFunc=self._pluginExportFunc,
)
opDataExport = self.dataExportApplet.topLevelOperator
opDataExport.SelectionNames.setValue(
["Object-Identities", "Tracking-Result", "Merger-Result"])
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.prepare_lane_for_export = self.prepare_lane_for_export
# configure export settings
# settings = {'file path': self.default_export_filename, 'compression': {}, 'file type': 'csv'}
# selected_features = ['Count', 'RegionCenter', 'RegionRadii', 'RegionAxes']
# opTracking.ExportSettings.setValue( (settings, selected_features) )
self._applets = []
self._applets.append(self.dataSelectionApplet)
if not self.fromBinary:
self._applets.append(self.thresholdTwoLevelsApplet)
self._applets.append(self.objectExtractionApplet)
if self.divisionDetectionApplet:
self._applets.append(self.divisionDetectionApplet)
self.batchProcessingApplet = BatchProcessingApplet(
self, "Batch Processing", self.dataSelectionApplet,
self.dataExportApplet)
self._applets.append(self.cellClassificationApplet)
self._applets.append(self.trackingApplet)
self._applets.append(self.dataExportApplet)
self._applets.append(self.batchProcessingApplet)
# Parse export and batch command-line arguments for headless mode
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.batchProcessingApplet.parse_known_cmdline_args(
workflow_cmdline_args)
else:
unused_args = None
self._data_export_args = None
self._batch_input_args = None
if unused_args:
logger.warning("Unused command-line args: {}".format(unused_args))
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(StructuredTrackingWorkflowBase, 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'
if self.fromBinary:
data_instructions += 'Use the "Binary Image" tab to load your segmentation image(s).'
else:
data_instructions += '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,
forceAxisOrder='txyzc',
instructionText=data_instructions,
max_lanes=1)
opDataSelection = self.dataSelectionApplet.topLevelOperator
if self.fromBinary:
opDataSelection.DatasetRoles.setValue( ['Raw Data', 'Binary Image'] )
else:
opDataSelection.DatasetRoles.setValue( ['Raw Data', 'Prediction Maps'] )
if not self.fromBinary:
self.thresholdTwoLevelsApplet = ThresholdTwoLevelsApplet( self,"Threshold and Size Filter","ThresholdTwoLevels" )
self.divisionDetectionApplet = ObjectClassificationApplet(workflow=self,
name="Division Detection (optional)",
projectFileGroupName="DivisionDetection",
selectedFeatures=configStructured.selectedFeaturesDiv)
self.cellClassificationApplet = ObjectClassificationApplet(workflow=self,
name="Object Count Classification",
projectFileGroupName="CountClassification",
selectedFeatures=configStructured.selectedFeaturesObjectCount)
self.cropSelectionApplet = CropSelectionApplet(self,"Crop Selection","CropSelection")
self.trackingFeatureExtractionApplet = TrackingFeatureExtractionApplet(name="Object Feature Computation",workflow=self, interactive=False)
self.objectExtractionApplet = ObjectExtractionApplet(name="Object Feature Computation",workflow=self, interactive=False)
self.annotationsApplet = AnnotationsApplet( name="Training", workflow=self )
opAnnotations = self.annotationsApplet.topLevelOperator
# self.default_training_export_filename = '{dataset_dir}/{nickname}-training_exported_data.csv'
# self.dataExportAnnotationsApplet = TrackingBaseDataExportApplet(self, "Training Export",default_export_filename=self.default_training_export_filename)
# opDataExportAnnotations = self.dataExportAnnotationsApplet.topLevelOperator
# opDataExportAnnotations.SelectionNames.setValue( ['User Training for Tracking', 'Object Identities'] )
# opDataExportAnnotations.WorkingDirectory.connect( opDataSelection.WorkingDirectory )
# self.dataExportAnnotationsApplet.set_exporting_operator(opAnnotations)
self.trackingApplet = StructuredTrackingApplet( name="Tracking - Structured Learning", workflow=self )
opStructuredTracking = self.trackingApplet.topLevelOperator
self.default_tracking_export_filename = '{dataset_dir}/{nickname}-tracking_exported_data.csv'
self.dataExportTrackingApplet = TrackingBaseDataExportApplet(self, "Tracking Result Export",default_export_filename=self.default_tracking_export_filename)
opDataExportTracking = self.dataExportTrackingApplet.topLevelOperator
opDataExportTracking.SelectionNames.setValue( ['Tracking Result', 'Merger Result', 'Object Identities'] )
opDataExportTracking.WorkingDirectory.connect( opDataSelection.WorkingDirectory )
self.dataExportTrackingApplet.set_exporting_operator(opStructuredTracking)
self.dataExportTrackingApplet.post_process_lane_export = self.post_process_lane_export
self._applets = []
self._applets.append(self.dataSelectionApplet)
if not self.fromBinary:
self._applets.append(self.thresholdTwoLevelsApplet)
self._applets.append(self.trackingFeatureExtractionApplet)
self._applets.append(self.divisionDetectionApplet)
self._applets.append(self.cellClassificationApplet)
self._applets.append(self.cropSelectionApplet)
self._applets.append(self.objectExtractionApplet)
self._applets.append(self.annotationsApplet)
# self._applets.append(self.dataExportAnnotationsApplet)
self._applets.append(self.trackingApplet)
self._applets.append(self.dataExportTrackingApplet)
if self.divisionDetectionApplet:
opDivDetection = self.divisionDetectionApplet.topLevelOperator
opDivDetection.SelectedFeatures.setValue(configConservation.selectedFeaturesDiv)
opDivDetection.LabelNames.setValue(['Not Dividing', 'Dividing'])
opDivDetection.AllowDeleteLabels.setValue(False)
opDivDetection.AllowAddLabel.setValue(False)
opDivDetection.EnableLabelTransfer.setValue(False)
opCellClassification = self.cellClassificationApplet.topLevelOperator
opCellClassification.SelectedFeatures.setValue(configConservation.selectedFeaturesObjectCount )
opCellClassification.SuggestedLabelNames.setValue( ['False Detection',] + [str(1) + ' Object'] + [str(i) + ' Objects' for i in range(2,10) ] )
opCellClassification.AllowDeleteLastLabelOnly.setValue(True)
opCellClassification.EnableLabelTransfer.setValue(False)