def preload_images(specs, fov_id_list):
'''This dictionary holds the first and last image
for all channels in all FOVS. It is passed to the UI so that the
figures can be populated much faster
'''
global p
# Intialized the dicionary
UI_images = {}
for fov_id in fov_id_list:
mm3.information("Preloading images for FOV {}.".format(fov_id))
UI_images[fov_id] = {}
for peak_id in specs[fov_id].keys():
image_data = mm3.load_stack(fov_id,
peak_id,
color=p['phase_plane'])
UI_images[fov_id][peak_id] = {
'first': None,
'last': None
} # init dictionary
# phase image at t=0. Rescale intenstiy and also cut the size in half
# old and new image size
first_image = p['channel_picker']['first_image']
img_size_old = image_data[first_image, :, :].shape
img_size_new = (int(img_size_old[1] / 2), int(img_size_old[0] / 2))
UI_images[fov_id][peak_id]['first'] = np.array(
Image.fromarray(
image_data[first_image, :, :]).resize(img_size_new))
# imresize(image_data[first_image,:,:], 0.5)
last_image = p['channel_picker']['last_image']
# phase image at end
UI_images[fov_id][peak_id]['last'] = np.array(
Image.fromarray(
image_data[last_image, :, :]).resize(img_size_new))
# imresize(image_data[last_image,:,:], 0.5)
return UI_images
# load specs file
specs = mm3.load_specs()
# print(specs) # for debugging
# make list of FOVs to process (keys of channel_mask file)
fov_id_list = sorted([fov_id for fov_id in specs.keys()])
# remove fovs if the user specified so
if user_spec_fovs:
fov_id_list[:] = [fov for fov in fov_id_list if fov in user_spec_fovs]
peaks_list = [
peak_id for peak_id, val in specs[fov_id_list[0]].items() if val == 1
]
img_height, img_width = mm3.load_stack(
fov_id_list[0], peaks_list[0], color=p['phase_plane'])[0, :, :].shape
# how many images total will we concatenate horizontally?
img_count = 0
for fov_id in fov_id_list:
fov_peak_count = len(
[peak_id for peak_id, val in specs[fov_id].items() if val == 1])
img_count += fov_peak_count
# placeholder array of img_height, and proper width to hold all pixels from this fov
phase_arr = np.zeros((230, img_width * img_count), 'uint16')
if namespace.cell_segs:
# p['seg_dir'] = 'segmented'
seg_arr = np.zeros((img_230height, img_width * img_count), 'uint16')
def track_loop(fov_id,
peak_id,
params,
tracks,
model_dict,
cell_number=6,
data_number=9,
img_file_name=None,
seg_file_name=None,
track_type='cells',
max_cell_number=6):
if img_file_name is None:
if track_type == 'cells':
seg_stack = mm3.load_stack(fov_id,
peak_id,
color=params['seg_img'])
img_stack = mm3.load_stack(fov_id,
peak_id,
color=params['phase_plane'])
elif track_type == 'foci':
seg_stack = mm3.load_stack(fov_id,
peak_id,
color=params['seg_img'])
img_stack = mm3.load_stack(fov_id,
peak_id,
color=params['foci']['foci_plane'])
else:
seg_stack = io.imread(seg_file_name)
img_stack = io.imread(img_file_name)
# run predictions for each tracking class
# consider only the top six cells for a given trap when doing tracking
frame_number = seg_stack.shape[0]
# sometimes a phase contrast image is missed and has no signal.
# This is a workaround for that problem
no_signal_frames = []
for k, img in enumerate(img_stack):
if track_type == 'foci':
if np.max(img) < 100:
no_signal_frames.append(k)
elif track_type == 'cells':
# if the mean phase image signal is less than 200, add its index to list
if np.mean(img) < 200:
no_signal_frames.append(k)
# loop through segmentation stack and replace frame from missed phase image
# with the prior frame.
for k, label_img in enumerate(seg_stack):
if k in no_signal_frames:
seg_stack[k, ...] = seg_stack[k - 1, ...]
if track_type == 'cells':
regions_by_time = [
measure.regionprops(label_image=img) for img in seg_stack
]
elif track_type == 'foci':
with open(p['cell_dir'] + '/all_cells.pkl', 'rb') as cell_file:
Cells = pickle.load(cell_file)
regions_by_time = []
for i, img in enumerate(seg_stack):
regs = measure.regionprops(label_image=img,
intensity_image=img_stack[i, :, :])
regs_sorted = mm3.sort_regions_in_list(regs)
regions_by_time.append(regs_sorted)
if track_type == 'cells':
# have generator yield info for top six cells in all frames
prediction_generator = mm3.PredictTrackDataGenerator(
regions_by_time,
batch_size=frame_number,
dim=(cell_number, 5, data_number),
track_type=track_type)
elif track_type == 'foci':
prediction_generator = mm3.PredictTrackDataGenerator(
regions_by_time,
batch_size=frame_number,
dim=(cell_number, 5, data_number),
track_type=track_type,
img_stack=img_stack,
images=True,
img_dim=(5, 256, 32))
cell_info = prediction_generator.__getitem__(0)
predictions_dict = {}
# run data through each classification model
for key, mod in model_dict.items():
# Run predictions and add to dictionary
if key in [
'zero_cell_model', 'one_cell_model', 'two_cell_model',
'geq_three_cell_model'
]:
continue
mm3.information(
'Predicting probability of {} events in FOV {}, trap {}.'.format(
'_'.join(key.split('_')[:-1]), fov_id, peak_id))
predictions_dict['{}_predictions'.format(key)] = mod.predict(cell_info)
if track_type == 'cells':
run_cells(
tracks,
peak_id,
fov_id,
params,
predictions_dict,
regions_by_time,
)
elif track_type == 'foci':
pred_dict = {}
(outbound1, outbound2, outbound3, outbound4, outbound5, outbound6,
pred_dict['appear_model_predictions']
) = predictions_dict['all_model_predictions']
# for this in predictions_dict['all_model_predictions']:
# print(this.shape)
# pred_dict['appear_model_predictions'],pred_dict['disappear_model_predictions'],pred_dict['appear_model_predictions'] = predictions_dict['all_model_predictions']
# take the -2nd element of each outbound array. the -1st is for "no focus", -2nd is for 'disappear, 0:6 are for migrate.
pred_dict['disappear_model_predicitons'] = np.transpose(
np.array([
outbound1[:, -2], outbound2[:, -2], outbound3[:, -2],
outbound4[:, -2], outbound5[:, -2], outbound6[:, -2]
]))
# take the 0:6 elements of each outbound prediction result.
pred_dict['migrate_model_predictions'] = np.concatenate([
outbound1[:, :6],
outbound2[:, :6],
outbound3[:, :6],
outbound4[:, :6],
outbound5[:, :6],
outbound6[:, :6],
],
axis=1)
# print(pred_dict['migrate_model_predictions'].shape)
run_foci(tracks,
peak_id,
fov_id,
params,
pred_dict,
regions_by_time,
Cells,
max_cell_number=max_cell_number,
appear_threshold=0.85)
def fov_plot_channels(fov_id,
crosscorrs,
specs,
outputdir='.',
phase_plane='c1'):
'''
Creates a plot with the channels with guesses for empties and full channels.
The plot is saved in PDF format.
Parameters
fov_id : str
file name of the hdf5 file name in originals
crosscorrs : dictionary
dictionary for cross correlation values for all fovs.
specs: dictionary
dictionary for channal assignment (Analyze/Don't Analyze/Background).
'''
mm3.information("Plotting channels for FOV %d." % fov_id)
# set up figure for user assited choosing
n_peaks = len(specs[fov_id].keys())
axw = 1
axh = 4 * axw
nrows = 3
ncols = int(n_peaks)
fig = plt.figure(num='none',
facecolor='w',
figsize=(ncols * axw, nrows * axh))
gs = gridspec.GridSpec(nrows, ncols, wspace=0.5, hspace=0.1, top=0.90)
# plot the peaks peak by peak using sorted list
sorted_peaks = sorted([peak_id for peak_id in specs[fov_id].keys()])
npeaks = len(sorted_peaks)
for n, peak_id in enumerate(sorted_peaks):
if crosscorrs:
peak_xc = crosscorrs[fov_id][
peak_id] # get cross corr data from dict
# load data for figure
image_data = mm3.load_stack(fov_id, peak_id, color=phase_plane)
first_img = rescale_intensity(
image_data[0, :, :]) # phase image at t=0
last_img = rescale_intensity(
image_data[-1, :, :]) # phase image at end
# append an axis handle to ax list while adding a subplot to the figure which has a
axhi = fig.add_subplot(gs[0, n])
axmid = fig.add_subplot(gs[1, n])
axlo = fig.add_subplot(gs[2, n])
# plot the first image in each channel in top row
ax = axhi
ax.imshow(first_img, cmap=plt.cm.gray, interpolation='nearest')
ax.axis('off')
ax.set_title(str(peak_id), fontsize=12)
if n == 0:
ax.set_ylabel("first time point")
# plot middle row using last time point with highlighting for empty/full
ax = axmid
ax.axis('off')
#ax.imshow(last_img,cmap=plt.cm.gray, interpolation='nearest')
#H,W = last_img.shape
#img = np.zeros((H,W,3))
if specs[fov_id][peak_id] == 1: # 1 means analyze, show green
#img[:,:,1]=last_img
cmap = plt.cm.Greens_r
elif specs[fov_id][peak_id] == 0: # 0 means reference, show blue
#img[:,:,2]=last_img
cmap = plt.cm.Blues_r
else: # otherwise show red, means don't analyze
#img[:,:,0]=last_img
cmap = plt.cm.Reds_r
ax.imshow(last_img, cmap=cmap, interpolation='nearest')
# format
if n == 0:
ax.set_ylabel("last time point")
# finally plot the cross correlations a cross time
ax = axlo
if crosscorrs: # don't try to plot if it's not there.
ccs = peak_xc['ccs'] # list of cc values
ax.plot(ccs, range(len(ccs)))
ax.set_title('avg=%1.2f' % peak_xc['cc_avg'], fontsize=8)
else:
ax.plot(np.zeros(10), range(10))
ax.get_xaxis().set_ticks([0.8, 0.9, 1.0])
ax.set_xlim((0.8, 1))
ax.tick_params('x', labelsize=8)
if not n == 0:
ax.set_yticks([])
else:
ax.set_ylabel("time index, CC on X")
fig.suptitle("FOV {:d}".format(fov_id), fontsize=14)
fileout = os.path.join(outputdir, 'fov_xy{:03d}.pdf'.format(fov_id))
fig.savefig(fileout, bbox_inches='tight', pad_inches=0)
plt.close('all')
mm3.information("Written FOV {}'s channels in {}".format(fov_id, fileout))
return specs
def fov_CNN_plot_channels(fov_id,
predictionDict,
specs,
outputdir='.',
phase_plane='c1'):
'''
Creates a plot with the channels with guesses for empties and full channels.
The plot is saved in PDF format.
Parameters
fov_id : str
file name of the hdf5 file name in originals
predictionDict : dictionary
dictionary for cross correlation values for all fovs.
specs: dictionary
dictionary for channal assignment (Analyze/Don't Analyze/Background).
'''
mm3.information("Plotting channels for FOV %d." % fov_id)
# set up figure for user assited choosing
n_peaks = len(specs[fov_id].keys())
axw = 1
axh = 4 * axw
nrows = 3
ncols = int(n_peaks)
fig = plt.figure(num='none',
facecolor='w',
figsize=(ncols * axw, nrows * axh))
gs = gridspec.GridSpec(nrows, ncols, wspace=0.5, hspace=0.1, top=0.90)
# plot the peaks peak by peak using sorted list
sorted_peaks = sorted([peak_id for peak_id in specs[fov_id].keys()])
npeaks = len(sorted_peaks)
for n, peak_id in enumerate(sorted_peaks):
if predictionDict:
predictions = predictionDict[fov_id][
peak_id] # get predictions array
# load data for figure
image_data = mm3.load_stack(fov_id, peak_id, color=phase_plane)
first_img = rescale_intensity(
image_data[0, :, :]) # phase image at t=0
last_img = rescale_intensity(
image_data[-1, :, :]) # phase image at end
# append an axis handle to ax list while adding a subplot to the figure which has a
axhi = fig.add_subplot(gs[0, n])
axmid = fig.add_subplot(gs[1, n])
axlo = fig.add_subplot(gs[2, n])
# plot the first image in each channel in top row
ax = axhi
ax.imshow(first_img, cmap=plt.cm.gray, interpolation='nearest')
ax.axis('off')
ax.set_title(str(peak_id), fontsize=12)
if n == 0:
ax.set_ylabel("first time point")
# plot middle row using last time point with highlighting for empty/full
ax = axmid
ax.axis('off')
#ax.imshow(last_img,cmap=plt.cm.gray, interpolation='nearest')
#H,W = last_img.shape
#img = np.zeros((H,W,3))
if specs[fov_id][peak_id] == 1: # 1 means analyze, show green
#img[:,:,1]=last_img
cmap = plt.cm.Greens_r
elif specs[fov_id][peak_id] == 0: # 0 means reference, show blue
#img[:,:,2]=last_img
cmap = plt.cm.Blues_r
else: # otherwise show red, means don't analyze
#img[:,:,0]=last_img
cmap = plt.cm.Reds_r
ax.imshow(last_img, cmap=cmap, interpolation='nearest')
# format
if n == 0:
ax.set_ylabel("last time point")
# finally plot the prediction values as horizontal bar chart
ax = axlo
if predictionDict:
ax.barh(range(len(predictions)), predictions)
#ax.vlines(x=p['channel_picker']['channel_picking_threshold'], ymin=-1, ymax=5, linestyles='dashed',colors='red')
ax.set_title('p', fontsize=8)
else:
ax.plot(np.zeros(10), range(10))
ax.set_xlim((0, 1)) # set limits to (0,1)
#ax.get_xaxis().set_ticks([])
if not n == 0:
ax.get_yaxis().set_ticks([])
else:
ax.set_yticklabels(
labels=["", "Good", "Empty", "Out-of-focus", "Defective"])
ax.set_ylabel("CNN prediction category")
fig.suptitle("FOV {:d}".format(fov_id), fontsize=14)
fileout = os.path.join(outputdir, 'fov_xy{:03d}.pdf'.format(fov_id))
fig.savefig(fileout, bbox_inches='tight', pad_inches=0)
plt.close('all')
mm3.information("Written FOV {}'s channels in {}".format(fov_id, fileout))
return specs
mm3.load_time_table()
# This dictionary holds information for all cells
# Cells = {}
# do lineage creation per fov, per trap
tracks = {}
for i,fov_id in enumerate(fov_id_list):
# tracks[fov_id] = {}
# update will add the output from make_lineages_function, which is a
# dict of Cell entries, into Cells
ana_peak_ids = [peak_id for peak_id in specs[fov_id].keys() if specs[fov_id][peak_id] == 1]
# ana_peak_ids = [9,13,15,19,25,33,36,37,38,39] # was used for debugging
for j,peak_id in enumerate(ana_peak_ids):
seg_stack = mm3.load_stack(fov_id, peak_id, color=p['seg_img'])
# run predictions for each tracking class
# consider only the top six cells for a given trap when doing tracking
cell_number = 6
frame_number = seg_stack.shape[0]
# get region properties
regions_by_time = [measure.regionprops(label_image=img) for img in seg_stack]
# have generator yield info for top six cells in all frames
prediction_generator = mm3.PredictTrackDataGenerator(regions_by_time, batch_size=frame_number, dim=(cell_number,5,9))
cell_info = prediction_generator.__getitem__(0)
predictions_dict = {}
# run data through each classification model
for key,mod in model_dict.items():
def track_loop(fov_id,
peak_id,
params,
tracks,
model_dict,
cell_number=6,
phase_file_name=None,
seg_file_name=None):
if phase_file_name is None:
seg_stack = mm3.load_stack(fov_id, peak_id, color=params['seg_img'])
phase_stack = mm3.load_stack(fov_id,
peak_id,
color=params['phase_plane'])
else:
seg_stack = io.imread(seg_file_name)
phase_stack = io.imread(phase_file_name)
# run predictions for each tracking class
# consider only the top six cells for a given trap when doing tracking
frame_number = seg_stack.shape[0]
# sometimes a phase contrast image is missed and has no signal.
# This is a workaround for that problem
no_signal_frames = []
for k, img in enumerate(phase_stack):
# if the mean phase image signal is less than 200, add its index to list
if np.mean(img) < 200:
no_signal_frames.append(k)
# loop through segmentation stack and replace frame from missed phase image
# with the prior frame.
for k, label_img in enumerate(seg_stack):
if k in no_signal_frames:
seg_stack[k, ...] = seg_stack[k - 1, ...]
regions_by_time = [
measure.regionprops(label_image=img) for img in seg_stack
]
# have generator yield info for top six cells in all frames
prediction_generator = mm3.PredictTrackDataGenerator(
regions_by_time, batch_size=frame_number, dim=(cell_number, 5, 9))
cell_info = prediction_generator.__getitem__(0)
predictions_dict = {}
# run data through each classification model
for key, mod in model_dict.items():
# Run predictions and add to dictionary
if key in [
'zero_cell_model', 'one_cell_model', 'two_cell_model',
'geq_three_cell_model'
]:
continue
mm3.information(
'Predicting probability of {} events in FOV {}, trap {}.'.format(
'_'.join(key.split('_')[:-1]), fov_id, peak_id))
predictions_dict['{}_predictions'.format(key)] = mod.predict(cell_info)
G, graph_df = mm3.initialize_track_graph(
peak_id=peak_id,
fov_id=fov_id,
experiment_name=params['experiment_name'],
predictions_dict=predictions_dict,
regions_by_time=regions_by_time,
born_threshold=0.85,
appear_threshold=0.85)
tracks.update(mm3.create_lineages_from_graph(G, graph_df, fov_id, peak_id))