def testAppletDeserialization(self):
g = Graph()
op = OpFake(graph=g)
dataExportApplet = TrackingBaseDataExportApplet(
op, "Tracking Result Export")
dataExportSerializer = dataExportApplet.dataSerializers[0]
with h5py.File(self.TEST_PROJECT_FILE) as testProject:
# serialize TrackingBaseDataExportApplet's topLevelOperator
opTrackingBaseDataExport = dataExportApplet.topLevelOperator
opTrackingBaseDataExport.SelectedPlugin.setValue('Fiji-MaMuT')
opTrackingBaseDataExport.SelectedExportSource.setValue('Plugin')
opTrackingBaseDataExport.AdditionalPluginArguments.setValue(
{'bdvFilePath': '/tmp/bdv.xml'})
dataExportSerializer.serializeToHdf5(testProject,
self.TEST_PROJECT_FILE)
# create new instance of TrackingBaseDataExportApplet and deserialize its topLevelOperator
dataExportApplet = TrackingBaseDataExportApplet(
op, "Tracking Result Export")
dataExportSerializer = dataExportApplet.dataSerializers[0]
dataExportSerializer.deserializeFromHdf5(testProject,
self.TEST_PROJECT_FILE)
# check deserialized values in applet's topLevelOperator
assert dataExportSerializer.topLevelOperator.SelectedPlugin.value == 'Fiji-MaMuT'
assert dataExportSerializer.topLevelOperator.SelectedExportSource.value == 'Plugin'
assert dataExportSerializer.topLevelOperator.AdditionalPluginArguments.value[
'bdvFilePath'] == '/tmp/bdv.xml'
def testAppletSerialization(self):
g = Graph()
op = OpFake(graph=g)
dataExportApplet = TrackingBaseDataExportApplet(
op, "Tracking Result Export")
dataExportSerializer = dataExportApplet.dataSerializers[0]
with h5py.File(self.TEST_PROJECT_FILE) as testProject:
opTrackingBaseDataExport = dataExportApplet.topLevelOperator
opTrackingBaseDataExport.SelectedPlugin.setValue('Fiji-MaMuT')
opTrackingBaseDataExport.SelectedExportSource.setValue('Plugin')
opTrackingBaseDataExport.AdditionalPluginArguments.setValue(
{'bdvFilePath': '/tmp/bdv.xml'})
dataExportSerializer.serializeToHdf5(testProject,
self.TEST_PROJECT_FILE)
# check serialized values
with h5py.File(self.TEST_PROJECT_FILE) as testProject:
assert testProject[
"Tracking Result Export/SelectedPlugin"].value.decode(
) == 'Fiji-MaMuT'
assert testProject[
"Tracking Result Export/SelectedExportSource"].value.decode(
) == 'Plugin'
assert testProject[
"Tracking Result Export/AdditionalPluginArguments/bdvFilePath"].value.decode(
) == '/tmp/bdv.xml'
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 data_export_applet():
op = Operator(graph=Graph())
dataExportApplet = TrackingBaseDataExportApplet(op,
"Tracking Result Export")
opTrackingBaseDataExport = dataExportApplet.topLevelOperator
opTrackingBaseDataExport.SelectedPlugin.setValue("Fiji-MaMuT")
opTrackingBaseDataExport.SelectedExportSource.setValue("Plugin")
opTrackingBaseDataExport.AdditionalPluginArguments.setValue(
{"bdvFilePath": "/tmp/bdv.xml"})
return 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']
super(ChaingraphTrackingWorkflow, 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 = ChaingraphTrackingApplet(workflow=self)
opTracking = self.trackingApplet.topLevelOperator
self.dataExportApplet = TrackingBaseDataExportApplet(
self, "Tracking Result Export")
opDataExport = self.dataExportApplet.topLevelOperator
opDataExport.SelectionNames.setValue(['Tracking'])
opDataExport.WorkingDirectory.connect(
self.dataSelectionApplet.topLevelOperator.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 test_applet_deserialization(project_path, data_export_applet):
with h5py.File(project_path, "w") as project_file:
data_export_applet.dataSerializers[0].serializeToHdf5(
project_file, project_path)
op = Operator(graph=Graph())
data_export_applet = TrackingBaseDataExportApplet(
op, "Tracking Result Export")
with h5py.File(project_path, "r") as project_file:
data_export_applet.dataSerializers[0].deserializeFromHdf5(
project_file, project_path)
opTrackingBaseDataExport = data_export_applet.dataSerializers[
0].topLevelOperator
assert opTrackingBaseDataExport.SelectedPlugin.value == "Fiji-MaMuT"
assert opTrackingBaseDataExport.SelectedExportSource.value == "Plugin"
assert opTrackingBaseDataExport.AdditionalPluginArguments.value[
"bdvFilePath"] == "/tmp/bdv.xml"
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,
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, *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']
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)
