Start updating morphology workflows

scripts/attributes/master.py

@@ -10,12 +10,13 @@ from .cilia_attributes import cilia_morphology
 from ..files.xml_utils import get_h5_path_from_xml
 
 
-def get_seg_path(folder, name, key):
+def get_seg_path(folder, name, key=None):
     xml_path = os.path.join(folder, 'segmentations', '%s.xml' % name)
     path = get_h5_path_from_xml(xml_path, return_absolute_path=True)
     assert os.path.exists(path), path
-    with h5py.File(path, 'r') as f:
-        assert key in f, "%s not in %s" % (key, str(list(f.keys())))
+    if key is not None:
+        with h5py.File(path, 'r') as f:
+            assert key in f, "%s not in %s" % (key, str(list(f.keys())))
     return path
 
 
@@ -59,13 +60,6 @@ def make_cell_tables(old_folder, folder, name, tmp_folder, resolution,
                         med_expression_path, vc_out,
                         tmp_folder, target)
 
-    # make table with morphology
-    morpho_out = os.path.join(table_folder, 'morphology.csv')
-    n_labels = len(label_ids)
-    write_morphology_cells(seg_path, base_out, nuc_mapping_table, morpho_out,
-                           n_labels, resolution, tmp_folder,
-                           target, max_jobs)
-
     # region and semantic mapping
     region_out = os.path.join(table_folder, 'regions.csv')
     # need to make sure the inputs are copied / updated in
@@ -76,6 +70,13 @@ def make_cell_tables(old_folder, folder, name, tmp_folder, resolution,
                       image_folder, segmentation_folder,
                       label_ids, tmp_folder, target, max_jobs)
 
+    # make table with morphology
+    morpho_out = os.path.join(table_folder, 'morphology.csv')
+    write_morphology_cells(seg_path, nuc_path,
+                           base_out, morpho_out,
+                           nuc_mapping_table, region_out,
+                           tmp_folder, target, max_jobs)
+
     # mapping to extrapolated intensities
     extrapol_mask = os.path.join(folder, 'images', 'sbem-6dpf-1-whole-mask-extrapolated.xml')
     extrapol_mask = get_h5_path_from_xml(extrapol_mask, return_absolute_path=True)
@@ -107,18 +108,20 @@ def make_nucleus_tables(old_folder, folder, name, tmp_folder, resolution,
 
     # make the basic attributes table
     base_out = os.path.join(table_folder, 'default.csv')
-    label_ids = base_attributes(seg_path, seg_key, base_out, resolution,
-                                tmp_folder, target=target, max_jobs=max_jobs,
-                                correct_anchors=True)
+    base_attributes(seg_path, seg_key, base_out, resolution,
+                    tmp_folder, target=target, max_jobs=max_jobs,
+                    correct_anchors=True)
 
+    # make the morphology attribute table
     xml_raw = os.path.join(folder, 'images', 'sbem-6dpf-1-whole-raw.xml')
     raw_path = get_h5_path_from_xml(xml_raw, return_absolute_path=True)
-    # make the morphology attribute table
+    cell_seg_path = get_seg_path(folder, 'sbem-6dpf-1-whole-segmented-cells-labels')
+    chromatin_seg_path = get_seg_path(folder, 'sbem-6dpf-1-whole-segmented-chromatin-labels')
     morpho_out = os.path.join(table_folder, 'morphology.csv')
-    n_labels = len(label_ids)
-    write_morphology_nuclei(seg_path, raw_path, base_out, morpho_out,
-                            n_labels, resolution, tmp_folder,
-                            target, max_jobs)
+    write_morphology_nuclei(raw_path, seg_path,
+                            cell_seg_path, chromatin_seg_path,
+                            base_out, morpho_out,
+                            tmp_folder, target, max_jobs)
 
     # mapping to extrapolated intensities
     extrapol_mask = os.path.join(folder, 'segmentations', 'sbem-6dpf-mask-extrapolated.xml')

scripts/attributes/morphology.py

@@ -5,24 +5,22 @@ from ..extension.attributes import MorphologyWorkflow
 
 
 def write_config(config_folder, config):
-    # something eats a lot of threads, let's at least reserve a few ...
-    config.update({'mem_limit': 24, 'threads_per_job': 4})
+    config.update({'mem_limit': 24})
     with open(os.path.join(config_folder, 'morphology.config'), 'w') as f:
         json.dump(config, f)
 
 
-def write_morphology_nuclei(seg_path, raw_path, table_in_path, table_out_path,
-                            n_labels, resolution, tmp_folder, target, max_jobs):
+def write_morphology_nuclei(raw_path, nucleus_seg_path, chromatin_seg_path,
+                            table_in_path, table_out_path,
+                            tmp_folder, target, max_jobs):
     """
     Write csv files of morphology stats for the nucleus segmentation
 
-    seg_path - string, file path to nucleus segmentation
     raw_path - string, file path to raw data
-    cell_table_path - string, file path to cell table
+    nucleus_seg_path - string, file path to nucleus segmentation
+    chromatin_seg_path - string, file path to chromatin segmentation
     table_in_path - string, file path to nucleus table
     table_out_path - string, file path to save new nucleus table
-    n_labels - int, number of labels
-    resolution - list or tuple, resolution of segmentation at scale 0
     tmp_folder - string, temporary folder
     target - string, computation target (slurm or local)
     max_jobs - maximal number of jobs
@@ -31,32 +29,37 @@ def write_morphology_nuclei(seg_path, raw_path, table_in_path, table_out_path,
     config_folder = os.path.join(tmp_folder, 'configs')
     write_config(config_folder, task.get_config()['morphology'])
 
-    seg_scale = 0
+    # TODO double check these values
+    scale = 3
     min_size = 18313  # Kimberly's lower size cutoff for nuclei
+    max_bb = ''  # TODO
     t = task(tmp_folder=tmp_folder, max_jobs=max_jobs,
              config_dir=config_folder, target=target,
-             segmentation_path=seg_path, in_table_path=table_in_path,
-             output_path=table_out_path, resolution=list(resolution),
-             seg_scale=seg_scale, raw_scale=3, min_size=min_size, max_size=None,
-             raw_path=raw_path, prefix='nuclei', number_of_labels=n_labels)
+             compute_cell_features=False, raw_path=raw_path,
+             nucleus_segmentation_path=nucleus_seg_path,
+             chromatin_segmentation_path=chromatin_seg_path,
+             in_table_path=table_in_path,
+             output_path=table_out_path,
+             scale=scale, min_size=min_size, max_bb=max_bb)
     ret = luigi.build([t], local_scheduler=True)
     if not ret:
         raise RuntimeError("Nucleus morphology computation failed")
 
 
-def write_morphology_cells(seg_path, table_in_path, cell_nuc_mapping_path, table_out_path,
-                           n_labels, resolution, tmp_folder, target, max_jobs):
+# TODO do we pass raw data?
+def write_morphology_cells(cell_seg_path, nucleus_seg_path,
+                           table_in_path, table_out_path,
+                           nucleus_mapping_path, region_path,
+                           resolution, tmp_folder, target, max_jobs):
 
     """
     Write csv files of morphology stats for both the nucleus and cell segmentation
 
-    seg_path - string, file path to cell segmentation
+    cell_seg_path - string, file path to cell segmentation
     table_in_path - string, file path to cell table
-    cell_nuc_mapping_path - string, file path to numpy array mapping cells to nuclei
+    nucleus_mapping_path - string, file path to numpy array mapping cells to nuclei
         (first column cell id, second nucleus id)
     table_out_path - string, file path to save new cell table
-    n_labels - int, number of labels
-    resolution - list or tuple, resolution of segmentation at scale 0
     tmp_folder - string, temporary folder
     target - string, computation target (slurm or local)
     max_jobs - maximal number of jobs
@@ -65,16 +68,22 @@ def write_morphology_cells(seg_path, table_in_path, cell_nuc_mapping_path, table
     config_folder = os.path.join(tmp_folder, 'configs')
     write_config(config_folder, task.get_config()['morphology'])
 
-    seg_scale = 2
+    # TODO check these values
+    scale = 2
     min_size = 88741  # Kimberly's lower size cutoff for cells
     max_size = 600000000  # Kimberly's upper size cutoff for cells
+    max_bb = ''
     t = task(tmp_folder=tmp_folder, max_jobs=max_jobs,
              config_dir=config_folder, target=target,
-             segmentation_path=seg_path, in_table_path=table_in_path,
-             output_path=table_out_path, resolution=list(resolution),
-             seg_scale=seg_scale, min_size=min_size, max_size=max_size,
-             mapping_path=cell_nuc_mapping_path, prefix='cells',
-             number_of_labels=n_labels)
+             compute_cell_features=True,
+             cell_segmentation_path=cell_seg_path,
+             nucleus_segmentation_path=nucleus_seg_path,
+             in_table_path=table_in_path,
+             output_path=table_out_path,
+             scale=scale, max_bb=max_bb,
+             min_size=min_size, max_size=max_size,
+             nucleus_mapping_path=nucleus_mapping_path,
+             region_mapping_path=region_path)
     ret = luigi.build([t], local_scheduler=True)
     if not ret:
         raise RuntimeError("Cell morphology computation failed")

scripts/extension/attributes/morphology.py

@@ -3,6 +3,7 @@
 import os
 import sys
 import json
+from math import ceil
 
 import luigi
 import nifty.tools as nt
@@ -12,7 +13,8 @@ import cluster_tools.utils.volume_utils as vu
 import cluster_tools.utils.function_utils as fu
 from cluster_tools.utils.task_utils import DummyTask
 from cluster_tools.cluster_tasks import SlurmTask, LocalTask
-from scripts.extension.attributes.morphology_impl import morphology_impl
+from scripts.extension.attributes.morphology_impl import (morphology_impl_cell,
+                                                          morphology_impl_nucleus)
 
 #
 # Morphology Attribute Tasks
@@ -27,32 +29,83 @@ class MorphologyBase(luigi.Task):
     src_file = os.path.abspath(__file__)
     allow_retry = False
 
-    # input volumes and graph
-    segmentation_path = luigi.Parameter()
+    # compute cell features or nucleus features?
+    compute_cell_features = luigi.BoolParameter()
+
+    # paths to raw data and segmentations
+    # if the raw path is None, we don't compute intensity features
+    raw_path = luigi.Parameter(default=None)
+    # we always need the nucleus segmentation
+    nucleus_segmentation_path = luigi.Paramter()
+    # we only need the cell segmentation if we compute cell morphology features
+    cell_segmentation_path = luigi.Parameter(default=None)
+    # we only need the chromatin segmentation if we compute nucleus features
+    chromatin_segmentation_path = luigi.Paramter(default=None)
+
+    # the scale used for computation, relative to the raw scale
+    scale = luigi.IntParameter(default=3)
+
+    # the input tables paths for the default table, the
+    # nucleus mapping table and the region mapping table
     in_table_path = luigi.Parameter()
+    # only need the mapping paths for the nucleus features
+    nucleus_mapping_path = luigi.Paramter(default=None)
+    region_mapping_path = luigi.Paramter(default=None)
+
+    # prefix for the output tables
     output_prefix = luigi.Parameter()
-    # resolution of the segmentation at full scale
-    resolution = luigi.ListParameter()
-    # scales of segmentation and raw data used for the computation
-    seg_scale = luigi.IntParameter()
-    raw_scale = luigi.IntParameter(default=3)
-    # prefix
-    prefix = luigi.Parameter()
-    number_of_labels = luigi.IntParameter()
-    # minimum and maximum sizes for objects
+
+    # minimum and maximum sizes for objects / bounding box
     min_size = luigi.IntParameter()
     max_size = luigi.IntParameter(default=None)
-    # path for cell nucleus mapping, that is used for additional
-    # table filtering
-    mapping_path = luigi.IntParameter(default='')
-    # input path for intensity calcuation
-    # if '', intensities will not be calculated
-    raw_path = luigi.Parameter(default='')
+    max_bb = luigi.IntParameter()
+
     dependency = luigi.TaskParameter(default=DummyTask())
 
     def requires(self):
         return self.dependency
 
+    def _update_config_for_cells(self, config):
+        # check the relevant inputs for the cell morphology
+        assert self.cell_segmentation_path is not None
+        assert self.nucleus_mapping_path is not None
+        assert self.region_mapping_path is not None
+        config.update({'cell_segmentation_path': self.cell_segmentation_path,
+                       'nucleus_segmentation_path': self.nucleus_segmentation_path,
+                       'raw_path': self.raw_path,
+                       'output_prefix': self.output_prefix,
+                       'in_table_path': self.in_table_path,
+                       'nucleus_mapping_path': self.nucleus_mapping_path,
+                       'region_mapping_path': self.region_mapping_path,
+                       'scale': self.scale, 'max_bb': self.max_bb,
+                       'min_size': self.min_size, 'max_size': self.max_size})
+        return config
+
+    def _update_config_for_nuclei(self, config):
+        # check the relevant inputs for the nucleus morphology
+        assert self.chromatin_segmentation_path is not None
+        assert self.raw_path is not None
+        config.update({'nucleus_segmentation_path': self.nucleus_segmentation_path,
+                       'chromatin_segmentation_path': self.chromatin_segmentation_path,
+                       'raw_path': self.raw_path,
+                       'output_prefix': self.output_prefix,
+                       'in_table_path': self.in_table_path,
+                       'scale': self.scale, 'max_bb': self.max_bb,
+                       'min_size': self.min_size, 'max_size': self.max_size})
+        return config
+
+    def _get_number_of_labels(self):
+        seg_path = self.cell_segmentation_path if self.compute_cell_features else\
+            self.nucleus_segmentation_path
+        key = 't00000/s00/0/cells'
+        with vu.file_reader(seg_path, 'r') as f:
+            n_labels = int(f[key].attrs['maxId']) + 1
+        return n_labels
+
+    def _compute_block_len(self, number_of_labels):
+        ids_per_job = int(ceil(float(number_of_labels) / self.max_jobs))
+        return ids_per_job
+
     def run_impl(self):
         # get the global config and init configs
         shebang = self.global_config_values()[0]
@@ -60,34 +113,35 @@ class MorphologyBase(luigi.Task):
 
         # load the task config
         config = self.get_task_config()
-        # we hard-code the chunk-size to 1000 for now
-        block_list = vu.blocks_in_volume([self.number_of_labels], [1000])
 
-        # update the config with input and graph paths and keys
-        # as well as block shape
-        config.update({'segmentation_path': self.segmentation_path,
-                       'output_prefix': self.output_prefix,
-                       'in_table_path': self.in_table_path,
-                       'raw_path': self.raw_path,
-                       'mapping_path': self.mapping_path,
-                       'seg_scale': self.seg_scale,
-                       'raw_scale': self.raw_scale,
-                       'resolution': self.resolution,
-                       'min_size': self.min_size,
-                       'max_size': self.max_size})
+        if self.compute_cell_features:
+            config = self._update_config_for_cells(config)
+        else:
+            config = self._update_config_for_nuclei(config)
 
+        # TODO match block size and number of blocks
+        # we hard-code the chunk-size to 1000 for now
+        number_of_labels = self._get_number_of_labels()
+        block_len = self._compute_block_len(number_of_labels)
+        block_list = vu.blocks_in_volume([number_of_labels], [block_len])
+        config.update({'block_len': block_len,
+                       'compute_cell_features': self.compute_cell_features,
+                       'number_of_labels': number_of_labels})
+
+        prefix = 'cells' if self.compute_cell_features else 'nuclei'
         # prime and run the job
         n_jobs = min(len(block_list), self.max_jobs)
-        self.prepare_jobs(n_jobs, block_list, config, self.prefix)
-        self.submit_jobs(n_jobs, self.prefix)
+        self.prepare_jobs(n_jobs, block_list, config, prefix)
+        self.submit_jobs(n_jobs, prefix)
 
         # wait till jobs finish and check for job success
         self.wait_for_jobs()
-        self.check_jobs(n_jobs, self.prefix)
+        self.check_jobs(n_jobs, prefix)
 
     def output(self):
+        prefix = 'cells' if self.compute_cell_features else 'nuclei'
         out_path = os.path.join(self.tmp_folder,
-                                '%s_%s.log' % (self.task_name, self.prefix))
+                                '%s_%s.log' % (self.task_name, prefix))
         return luigi.LocalTarget(out_path)
 
 
@@ -108,6 +162,57 @@ class MorphologySlurm(MorphologyBase, SlurmTask):
 #
 
 
+def _morphology_nuclei(config, table, label_start, label_stop):
+    # paths to raw data, nucleus segmentation and chromatin segmentation
+    raw_path = config['raw_path']
+    nucleus_segmentation_path = config['nucleus_segmentation_path']
+    chromatin_segmentation_path = config['chromatin_segmentation_path']
+    # minimal / maximal size and maximal bounding box volume
+    min_size, max_size, max_bb = config['min_size'], config['max_size'], config['max_bb']
+    # scale for nucleus segmentation, raw data and chromatin segmentation
+    raw_scale = config['scale']
+    nucleus_scale = raw_scale - 3
+    chromatin_scale = raw_scale - 1  # TODO is this correct?
+    # nucleus and chromatin resolution are hard-coded for now
+    nucleus_resolution = [0.1, 0.08, 0.08]
+    chromatin_resolution = [0.025, 0.02, 0.02]  # TODO is this correct?
+    stats = morphology_impl_nucleus(nucleus_segmentation_path, raw_path,
+                                    chromatin_segmentation_path,
+                                    table, min_size, max_size, max_bb,
+                                    nucleus_resolution, chromatin_resolution,
+                                    nucleus_scale, raw_scale, chromatin_scale,
+                                    label_start, label_stop)
+    return stats
+
+
+def _morphology_cells(config, table, label_start, label_stop):
+    # paths to raw data, nucleus segmentation and chromatin segmentation
+    raw_path = config['raw_path']
+    cell_segmentation_path = config['cell_segmentation_path']
+    nucleus_segmentation_path = config['nucleus_segmentation_path']
+    # minimal / maximal size and maximal bounding box volume
+    min_size, max_size, max_bb = config['min_size'], config['max_size'], config['max_bb']
+    # scale for nucleus segmentation, raw data and chromatin segmentation
+    raw_scale = config['scale']
+    nucleus_scale = raw_scale - 3
+    cell_scale = raw_scale - 1  # TODO is this correct?
+    # nucleus and chromatin resolution are hard-coded for now
+    nucleus_resolution = [0.1, 0.08, 0.08]
+    cell_resolution = [0.025, 0.02, 0.02]  # TODO is this correct?
+    # mapping from cells to nuclei and from cells to regions
+    nucleus_mapping_path = config['mapping_path']
+    region_mapping_path = config['region_mapping_path']
+    stats = morphology_impl_cell(cell_segmentation_path, raw_path,
+                                 nucleus_segmentation_path,
+                                 table, nucleus_mapping_path,
+                                 region_mapping_path,
+                                 min_size, max_size, max_bb,
+                                 cell_resolution, nucleus_resolution,
+                                 cell_scale, raw_scale, nucleus_scale,
+                                 label_start, label_stop)
+    return stats
+
+
 def morphology(job_id, config_path):
 
     fu.log("start processing job %i" % job_id)
@@ -116,38 +221,34 @@ def morphology(job_id, config_path):
     # get the config
     with open(config_path) as f:
         config = json.load(f)
-    segmentation_path = config['segmentation_path']
-    in_table_path = config['in_table_path']
-    raw_path = config['raw_path']
-    mapping_path = config['mapping_path']
-    output_prefix = config['output_prefix']
-
-    min_size = config['min_size']
-    max_size = config['max_size']
-
-    resolution = config['resolution']
-    raw_scale = config['raw_scale']
-    seg_scale = config['seg_scale']
-
-    block_list = config['block_list']
 
     # read the base table
+    in_table_path = config['in_table_path']
     table = pd.read_csv(in_table_path, sep='\t')
 
-    # get the label ranges for this job
+    # determine the start and stop label for this job
+    block_list = config['block_list']
+    block_len = config['block_len']
+    assert len(block_list) == 1, "Expected a single block, got %i" % len(block_list)
+
+    # get the label range for this job
     n_labels = table.shape[0]
-    blocking = nt.blocking([0], [n_labels], [1000])
-    label_starts, label_stops = [], []
-    for block_id in block_list:
-        block = blocking.getBlock(block_id)
-        label_starts.append(block.begin[0])
-        label_stops.append(block.end[0])
-
-    stats = morphology_impl(segmentation_path, raw_path, table, mapping_path,
-                            min_size, max_size,
-                            resolution, raw_scale, seg_scale,
-                            label_starts, label_stops)
+    blocking = nt.blocking([0], [n_labels], [block_len])
+    block = blocking.getBlock(block_list[0])
+    label_start, label_stop = block.begin, block.end
+
+    # do we compute cell or nucleus features ?
+    compute_cell_features = config['compute_cell_features']
 
+    if compute_cell_features:
+        fu.log("Compute morphology features for cells")
+        stats = _morphology_cells(config, table, label_start, label_stop)
+    else:
+        fu.log("Compute morphology features for nuclei")
+        stats = _morphology_nuclei(config, table, label_start, label_stop)
+
+    # write the result
+    output_prefix = config['output_prefix']
     output_path = output_prefix + '_job%i.csv' % job_id
     fu.log("Save result to %s" % output_path)
     stats.to_csv(output_path, index=False, sep='\t')

scripts/extension/attributes/morphology_impl.py

@@ -394,7 +394,7 @@ def morphology_impl_nucleus(nucleus_segmentation_path, raw_path, chromatin_path,
                             max_bb,
                             nucleus_resolution, chromatin_resolution,
                             nucleus_seg_scale, raw_scale, chromatin_scale,
-                            label_starts, label_stops):
+                            label_start, label_stop):
     """ Compute morphology features for nucleus segmentation.
 
        Can compute features for multiple label ranges. If you want to
@@ -418,8 +418,8 @@ def morphology_impl_nucleus(nucleus_segmentation_path, raw_path, chromatin_path,
            nucleus_seg_scale [int] - scale level of the segmentation.
            raw_scale [int] - scale level of the raw data
            chromatin_scale [int] - scale level of the segmentation.
-           label_starts [listlike] - list with label start positions
-           label_stops [listlike] - list with label stop positions
+           label_start [int] - label start position
+           label_stop [int] - label stop position
        """
 
     # keys for the different scales
@@ -463,15 +463,14 @@ def morphology_impl_nucleus(nucleus_segmentation_path, raw_path, chromatin_path,
         ds = f[nucleus_seg_key]
 
         stats = []
-        for label_a, label_b in zip(label_starts, label_stops):
-            log("Computing features from label-id %i to %i" % (label_a, label_b))
-            stats.extend(morphology_features_for_label_range(table, ds, ds_raw,
-                                                             ds_chromatin,
-                                                             None,
-                                                             scale_factor_nucleus_seg, scale_factor_raw,
-                                                             scale_factor_chromatin,
-                                                             None,
-                                                             label_a, label_b))
+        log("Computing features from label-id %i to %i" % (label_start, label_stop))
+        stats = morphology_features_for_label_range(table, ds, ds_raw,
+                                                    ds_chromatin,
+                                                    None,
+                                                    scale_factor_nucleus_seg, scale_factor_raw,
+                                                    scale_factor_chromatin,
+                                                    None,
+                                                    label_start, label_stop)
 
     for var in f_raw, f_chromatin:
         if var is not None:
@@ -492,7 +491,7 @@ def morphology_impl_cell(cell_segmentation_path, raw_path,
                          max_bb,
                          cell_resolution, nucleus_resolution,
                          cell_seg_scale, raw_scale, nucleus_seg_scale,
-                         label_starts, label_stops):
+                         label_start, label_stop):
     """ Compute morphology features for cell segmentation.
 
        Can compute features for multiple label ranges. If you want to
@@ -522,8 +521,8 @@ def morphology_impl_cell(cell_segmentation_path, raw_path,
            cell_seg_scale [int] - scale level of the segmentation
            raw_scale [int] - scale level of the raw data
            nucleus_seg_scale [int] - scale level of the segmentation.
-           label_starts [listlike] - list with label start positions
-           label_stops [listlike] - list with label stop positions
+           label_start [int] - label start position
+           label_stop [int] - label stop position
        """
 
     # keys for the different scales
@@ -565,16 +564,14 @@ def morphology_impl_cell(cell_segmentation_path, raw_path,
     with h5py.File(cell_segmentation_path, 'r') as f:
         ds = f[cell_seg_key]
 
-        stats = []
-        for label_a, label_b in zip(label_starts, label_stops):
-            log("Computing features from label-id %i to %i" % (label_a, label_b))
-            stats.extend(morphology_features_for_label_range(table, ds, ds_raw,
-                                                             None,
-                                                             ds_nucleus,
-                                                             scale_factor_cell_seg, scale_factor_raw,
-                                                             None,
-                                                             scale_factor_nucleus,
-                                                             label_a, label_b))
+        log("Computing features from label-id %i to %i" % (label_start, label_stop))
+        stats = morphology_features_for_label_range(table, ds, ds_raw,
+                                                    None,
+                                                    ds_nucleus,
+                                                    scale_factor_cell_seg, scale_factor_raw,
+                                                    None,
+                                                    scale_factor_nucleus,
+                                                    label_start, label_stop)
 
     for var in f_raw, f_nucleus:
         if var is not None:

scripts/extension/attributes/workflow.py

@@ -36,27 +36,35 @@ class MergeTables(luigi.Task):
 
 
 class MorphologyWorkflow(WorkflowBase):
-    # input volumes and graph
-    segmentation_path = luigi.Parameter()
+    # compute cell features or nucleus features?
+    compute_cell_features = luigi.BoolParameter()
+
+    # paths to raw data and segmentations
+    # if the raw path is None, we don't compute intensity features
+    raw_path = luigi.Parameter(default=None)
+    # we always need the nucleus segmentation
+    nucleus_segmentation_path = luigi.Paramter()
+    # we only need the cell segmentation if we compute cell morphology features
+    cell_segmentation_path = luigi.Parameter(default=None)
+    # we only need the chromatin segmentation if we compute nucleus features
+    chromatin_segmentation_path = luigi.Paramter(default=None)
+
+    # the scale used for computation, relative to the raw scale
+    scale = luigi.IntParameter(default=3)
+
+    # the input tables paths for the default table, the
+    # nucleus mapping table and the region mapping table
     in_table_path = luigi.Parameter()
-    output_path = luigi.Parameter()
-    # resolution of the segmentation at full scale
-    resolution = luigi.ListParameter()
-    # scales of segmentation and raw data used for the computation
-    seg_scale = luigi.IntParameter()
-    raw_scale = luigi.IntParameter(default=3)
-    # prefix
-    prefix = luigi.Parameter()
-    number_of_labels = luigi.IntParameter()
-    # minimum and maximum sizes for objects
+    # only need the mapping paths for the nucleus features
+    nucleus_mapping_path = luigi.Paramter(default=None)
+    region_mapping_path = luigi.Paramter(default=None)
+
+    # minimum and maximum sizes for objects / bounding box
     min_size = luigi.IntParameter()
     max_size = luigi.IntParameter(default=None)
-    # path for cell nucleus mapping, that is used for additional
-    # table filtering
-    mapping_path = luigi.IntParameter(default='')
-    # input path for intensity calcuation
-    # if '', intensities will not be calculated
-    raw_path = luigi.Parameter(default='')
+    max_bb = luigi.IntParameter()
+
+    output_path = luigi.Paramter()
 
     def requires(self):
         out_prefix = os.path.join(self.tmp_folder, 'sub_table_%s' % self.prefix)
@@ -64,12 +72,15 @@ class MorphologyWorkflow(WorkflowBase):
                               self._get_task_name('Morphology'))
         dep = morpho_task(tmp_folder=self.tmp_folder, config_dir=self.config_dir,
                           dependency=self.dependency, max_jobs=self.max_jobs,
-                          segmentation_path=self.segmentation_path,
+                          compute_cell_features=self.compute_cell_features,
+                          raw_path=self.raw_path,
+                          nucleus_segmentation_path=self.nucleus_segmentation_path,
+                          cell_segmentation_path=self.cell_segmentation_path,
+                          chromatin_segmentation_path=self.chromatin_segmentation_path,
                           in_table_path=self.in_table_path, output_prefix=out_prefix,
-                          resolution=self.resolution, seg_scale=self.seg_scale, raw_scale=self.raw_scale,
-                          prefix=self.prefix, number_of_labels=self.number_of_labels,
-                          min_size=self.min_size, max_size=self.max_size, mapping_path=self.mapping_path,
-                          raw_path=self.raw_path)
+                          nucleus_mapping_path=self.nucleus_mapping_path,
+                          region_mapping_path=self.region_mapping_path,
+                          min_size=self.min_size, max_size=self.max_size, max_bb=self.max_bb)
         dep = MergeTables(output_prefix=out_prefix, output_path=self.output_path,
                           max_jobs=self.max_jobs, dependency=dep)