def save_region_pipeline(self, primary_channel_name=None, secondary_channel_name=None):
# 1. make unique key
unique_key = '{}{}-{}'.format(primary_channel_name, secondary_channel_name, random_string())
# 2. format and save file
pipeline_text = region_pipeline(unique_key, primary_channel_name, secondary_channel_name)
with open(os.path.join(self.pipeline_path, 'regions.cppipe')) as open_pipeline_file:
open_pipeline_file.write(pipeline_text)
return unique_key
def save_marker_pipeline(self, series_name=None, primary_channel_name=None, secondary_channel_name=None):
# 1. make unique key
unique = random_string()
unique_key = '{}{}-{}'.format(primary_channel_name, secondary_channel_name, unique)
# 2. format and save file
pipeline_text = marker_pipeline('{}_s{}_{}_'.format(self.name, series_name, unique), unique_key, primary_channel_name, secondary_channel_name)
with open(os.path.join(self.pipeline_path, 'markers.cppipe'), 'w+') as open_pipeline_file:
open_pipeline_file.write(pipeline_text)
return unique, unique_key
def segment(self, marker_channel_name='-zcomp', threshold_correction_factor=1.2, background=True):
unique = random_string() # defines a single identifier for this run
unique_key = '{}{}-{}'.format(marker_channel_name, self.name, unique)
# setup
print('getting marker channel')
marker_channel = self.composite.channels.get(name=marker_channel_name)
# 1. create primary from markers with marker_channel
print('running primary')
marker_channel_primary_name = marker_channel.primary(unique=unique)
# 2. create pipeline and run
print('run pipeline')
self.composite.experiment.save_marker_pipeline(series_name=self.composite.series.name, primary_channel_name=marker_channel_primary_name, secondary_channel_name=self.name, threshold_correction_factor=threshold_correction_factor, background=background, unique=unique, unique_key=unique_key)
self.composite.experiment.run_pipeline(series_ts=self.composite.series.ts)
print('import masks')
# 3. import masks and create new mask channel
cp_out_file_list = [f for f in os.listdir(self.composite.experiment.cp_path) if (unique_key in f and '.tiff' in f)]
# make new channel that gets put in mask path
cp_template = self.composite.templates.get(name='cp')
mask_template = self.composite.templates.get(name='mask')
mask_channel = self.composite.mask_channels.create(name=unique_key)
region_mask_channel = self.composite.mask_channels.get(name__contains=self.composite.current_region_unique)
for cp_out_file in cp_out_file_list:
array = imread(os.path.join(self.composite.experiment.cp_path, cp_out_file))
metadata = cp_template.dict(cp_out_file)
mask_channel.get_or_create_mask(array, int(metadata['t']))
print('import data files')
# 4. import datafiles and access data
data_file_list = [f for f in os.listdir(self.composite.experiment.cp_path) if (unique in f and '.csv' in f)]
for df_name in data_file_list:
data_file, data_file_created, status = self.composite.get_or_create_data_file(self.composite.experiment.cp_path, df_name)
# 5. create cells and cell instances from tracks
cell_data_file = self.composite.data_files.get(id_token=unique, data_type='Cells')
data = cell_data_file.load()
# load masks and associate with grayscale id's
for t in range(self.composite.series.ts):
mask_mask = mask_channel.masks.get(t=t)
mask = mask_mask.load()
# load region mask
region_mask_mask = region_mask_channel.masks.get(t=t)
region_mask = region_mask_mask.load()
t_data = list(filter(lambda d: int(d['ImageNumber'])-1==t, data))
markers = marker_channel.markers.filter(track_instance__t=t)
for marker in markers:
# 1. create cell
cell, cell_created = self.composite.experiment.cells.get_or_create(series=self.composite.series, track=marker.track)
# 2. create cell instance
cell_instance, cell_instance_created = cell.instances.get_or_create(experiment=cell.experiment,
series=cell.series,
track_instance=marker.track_instance)
# 3. create cell mask
gray_value_id = mask[marker.r, marker.c]
region_gray_value_id = region_mask[marker.r, marker.c]
region_instance = self.composite.series.region_instances.filter(region_track_instance__t=t, mode_gray_value_id=region_gray_value_id)
if region_instance:
region_instance = region_instance[0]
else:
region_instance = None
for ri in self.composite.series.region_instances.filter(region_track_instance__t=t):
gray_value_ids = [ri_mask.gray_value_id for ri_mask in ri.masks.all()]
if region_instance is None and region_gray_value_id in gray_value_ids:
region_instance = ri
if gray_value_id!=0:
cell_mask = cell_instance.masks.create(experiment=cell.experiment,
series=cell.series,
cell=cell,
region=region_instance.region if region_instance is not None else None,
region_instance=region_instance if region_instance is not None else None,
channel=mask_channel,
mask=mask_mask,
marker=marker,
gray_value_id=gray_value_id)
cell_mask_data = list(filter(lambda d: int(d['ObjectNumber'])==cell_mask.gray_value_id, t_data))[0]
# 4. assign data
cell_mask.r = cell_mask.marker.r
cell_mask.c = cell_mask.marker.c
cell_mask.t = t
cell_mask.AreaShape_Area = float(cell_mask_data['AreaShape_Area']) if str(cell_mask_data['AreaShape_Area']) != 'nan' else -1.0
cell_mask.AreaShape_Compactness = float(cell_mask_data['AreaShape_Compactness']) if str(cell_mask_data['AreaShape_Compactness']) != 'nan' else -1.0
cell_mask.AreaShape_Eccentricity = float(cell_mask_data['AreaShape_Eccentricity']) if str(cell_mask_data['AreaShape_Eccentricity']) != 'nan' else -1.0
cell_mask.AreaShape_EulerNumber = float(cell_mask_data['AreaShape_EulerNumber']) if str(cell_mask_data['AreaShape_EulerNumber']) != 'nan' else -1.0
cell_mask.AreaShape_Extent = float(cell_mask_data['AreaShape_Extent']) if str(cell_mask_data['AreaShape_Extent']) != 'nan' else -1.0
cell_mask.AreaShape_FormFactor = float(cell_mask_data['AreaShape_FormFactor']) if str(cell_mask_data['AreaShape_FormFactor']) != 'nan' else -1.0
cell_mask.AreaShape_MajorAxisLength = float(cell_mask_data['AreaShape_MajorAxisLength']) if str(cell_mask_data['AreaShape_MajorAxisLength']) != 'nan' else -1.0
cell_mask.AreaShape_MaximumRadius = float(cell_mask_data['AreaShape_MaximumRadius']) if str(cell_mask_data['AreaShape_MaximumRadius']) != 'nan' else -1.0
cell_mask.AreaShape_MeanRadius = float(cell_mask_data['AreaShape_MeanRadius']) if str(cell_mask_data['AreaShape_MeanRadius']) != 'nan' else -1.0
cell_mask.AreaShape_MedianRadius = float(cell_mask_data['AreaShape_MedianRadius']) if str(cell_mask_data['AreaShape_MedianRadius']) != 'nan' else -1.0
cell_mask.AreaShape_MinorAxisLength = float(cell_mask_data['AreaShape_MinorAxisLength']) if str(cell_mask_data['AreaShape_MinorAxisLength']) != 'nan' else -1.0
cell_mask.AreaShape_Orientation = float(cell_mask_data['AreaShape_Orientation']) if str(cell_mask_data['AreaShape_Orientation']) != 'nan' else -1.0
cell_mask.AreaShape_Perimeter = float(cell_mask_data['AreaShape_Perimeter']) if str(cell_mask_data['AreaShape_Perimeter']) != 'nan' else -1.0
cell_mask.AreaShape_Solidity = float(cell_mask_data['AreaShape_Solidity']) if str(cell_mask_data['AreaShape_Solidity']) != 'nan' else -1.0
cell_mask.save()
# for now
cell_instance.set_from_masks(unique)
else:
# for now
cell_instance.set_from_markers()
# 6. calculate cell velocities
print('calculating velocities...')
for cell in self.composite.experiment.cells.all():
cell.calculate_velocities()
cell.calculate_confidences()
return unique
def segment_regions(self, region_marker_channel_name='-zbf', threshold_correction_factor=1.2, background=True):
unique = random_string() # defines a single identifier for this run
unique_key = '{}{}-{}'.format(region_marker_channel_name, self.name, unique)
# setup
region_marker_channel = self.composite.channels.get(name=region_marker_channel_name)
# 1. create region primary
print('running primary')
region_marker_channel_primary_name = region_marker_channel.region_primary(unique=unique)
# 2. create pipeline and run
self.composite.experiment.save_region_pipeline(series_name=self.composite.series.name, primary_channel_name=region_marker_channel_primary_name, secondary_channel_name=self.name, threshold_correction_factor=threshold_correction_factor, background=background, unique=unique, unique_key=unique_key)
self.composite.experiment.run_pipeline(series_ts=self.composite.series.ts, key='regions')
# 3. import masks
print('import masks')
cp_out_file_list = [f for f in os.listdir(self.composite.experiment.cp_path) if (unique_key in f and '.tiff' in f)]
# make new channel that gets put in mask path
cp_template = self.composite.templates.get(name='cp')
mask_template = self.composite.templates.get(name='mask')
mask_channel = self.composite.mask_channels.create(name=unique_key)
for cp_out_file in cp_out_file_list:
array = imread(os.path.join(self.composite.experiment.cp_path, cp_out_file))
metadata = cp_template.dict(cp_out_file)
mask_channel.get_or_create_mask(array, int(metadata['t']))
# 4. create regions and tracks
print('create regions and tracks...')
mask_mask = mask_channel.masks.get(t=0) # this is only the first mask. All others will have the same gray values.
mask = mask_mask.load()
for t in range(self.composite.series.ts):
# mask_mask = mask_channel.masks.get(t=t) # this can be used if the regions are properly tracked.
# mask = mask_mask.load()
region_markers = region_marker_channel.region_markers.filter(region_track_instance__t=t)
for region_marker in region_markers:
# 1. create cell
region, region_created = self.composite.experiment.regions.get_or_create(series=self.composite.series, region_track=region_marker.region_track, name=region_marker.region_track.name)
# 2. create cell instance
region_instance, region_instance_created = region.instances.get_or_create(experiment=region.experiment,
series=region.series,
region_track_instance=region_marker.region_track_instance)
# 3. create cell mask
# gray value id is only taken from the first frame since the regions are tracked
# and will retain their id.
gray_value_id = mask[region_marker.r, region_marker.c]
region_mask = region_instance.masks.create(experiment=region.experiment,
series=region.series,
region=region,
mask=mask_mask)
region_mask.gray_value_id = gray_value_id
region_mask.save()
for region_track_instance in region_marker_channel.region_track_instances.filter(t=t):
gray_value_ids = [region_mask.gray_value_id for region_mask in region_track_instance.region_instance.masks.filter(mask=mask_mask)]
region_track_instance.region_instance.mode_gray_value_id = int(mode(gray_value_ids)[0][0])
region_track_instance.region_instance.save()
self.composite.current_region_unique = unique
self.composite.save()
return unique
