def save_image_process_steps(self):
"""
Save configures processing steps to csv
:return:
"""
# prepare processing steps for writing to file
proc_steps = list()
# add id to the start
proc_steps.append(self.image_info['ID'])
for step in self.processing_steps[1:]:
# filter name
proc_steps.append(step[0])
# filter params
if len(step) > 1:
proc_steps[-1] += '='
# add parameters
for id, param in enumerate(step[1:]):
if id > 0:
proc_steps[-1] += ','
# is param a range? then convert
if isinstance(param, range):
param = ImageProcessing.get_param_from_range(param)
proc_steps[-1] += str(param)
# write to processing file
ImageHandler.update_exp_csv(self.image_info['ID'],
cfg.file_processing,
proc_steps)
def get_filters(image):
"""
Retrieve filters for image from configuration
:param image:
:return:
"""
# processing steps for image
processing_steps = list()
with open(cfg.file_processing, 'r') as csvfile:
image_reader = csv.reader(csvfile,
delimiter=cfg.CSV_DEL,
quotechar=cfg.CSV_QUOT)
# find filters for image
for row in image_reader:
if row[0] == ImageHandler.extract_expnum_from_ID(image['ID']):
for filter in range(1, len(row)):
# get filter and parameters
split_filter = row[filter].split(cfg.PROC_PARAMS)
# build the filter and parameter list
steps = list()
steps.append(split_filter[0])
# Does the filter have parameters?
if len(split_filter) > 1:
# split parameters
split_params = split_filter[1].split(
cfg.PROC_PARAMS_DEL)
for param in split_params:
# is parameter a digit?
if param.isdigit():
param = int(param)
steps.append(param)
processing_steps.append(steps)
break
csvfile.close()
return processing_steps
def train_with_exts(self):
"""
Use extensions of experiment to train the classifier
:return:
"""
# get extensions from experiment
self.ext_infos = ImageHandler.get_ext_infos_by_expnum(self.segmentation.image_info['ID'])
# create train and target vectors
self.train_data, self.target_data = self.create_train_target_from_ext_infos()
# create unkown vector for image
self.unknown_data, self.unknown_map = self.create_unknown()
# train classifier and get probabilities
self.nuclei_probas = self.train_and_predict()
# add probability to nuclei
self.add_nuclei_probas_to_params()
def view_images(img_list,
are_objects=False,
cmap='gray',
display=True,
save=False):
"""
View individual images
:param are_objects:
:param cmap:
:param display:
:param save:
:return:
"""
if save:
# create temporary directory to save the images
tmp_dir = ImageHandler.create_tmp_dir()
if display:
# create a plot to show images
fig, axes = plt.subplots(ncols=len(img_list),
figsize=(2 * len(img_list), 2),
sharex=True,
sharey=True)
for i, img in enumerate(img_list):
if save:
# save images in temporary directory
plt.imsave((tmp_dir + '/Image-%i') % i, img, cmap=cmap)
if display:
# displat the objects
if are_objects:
axes[i].imshow(img['img'], cmap='Spectral')
axes[i].set_title('Obj: %i' % img['label'])
else:
axes[i].imshow(img, cmap=cmap)
axes[i].set_title('Image: %i' % i)
axes[i].axis('off')
axes[i].set_adjustable('box-forced')
app = QtGui.QApplication(sys.argv)
# update fonts
import matplotlib.pylab as plt
params = {
'axes.titlesize': cfg.fontsdict_plot['fontsize'],
'xtick.labelsize': cfg.fontsdict_plot['fontsize'],
'ytick.labelsize': cfg.fontsdict_plot['fontsize']
}
plt.rcParams.update(params)
selected_info_IDs = ['N1-19-9', 'N1-19-22', 'N1-19-23', 'N1-19-24']
#selected_info_IDs = ['N1-19-9', 'N1-19-23']
# open window to select nuclei criteria
loaded_infos = ImageHandler.load_image_infos()
infos = list()
# processing steps
processing_steps = [['DIL', 'y', 2], ['CONV_BIT', 16]]
for info in loaded_infos:
info_ID = info['ID']
if info_ID in selected_info_IDs:
infos.append(info)
for info in infos:
seg = Segmentation(info)
seg.load()
img_path = seg.get_results_dir().tmp + 'contact_surface.tif'
# show the editor to choose images
app = QtGui.QApplication(sys.argv)
# update fonts
import matplotlib.pylab as plt
params = {'axes.titlesize': cfg.fontsdict_plot['fontsize'],
'xtick.labelsize': cfg.fontsdict_plot['fontsize'],
'ytick.labelsize': cfg.fontsdict_plot['fontsize']}
plt.rcParams.update(params)
#selected_info_IDs = ['N1-19-9', 'N1-19-22', 'N1-19-23', 'N1-19-24']
selected_info_IDs = ['N1-19-23']
# open window to select nuclei criteria
loaded_infos = ImageHandler.load_image_infos()
infos = list()
# processing steps
processing_steps = [['DIL', 'y', 2],
['CONV_BIT', 16]]
# calculate compactness?
calc_compactness = False
for info in loaded_infos:
info_ID = info['ID']
if info_ID in selected_info_IDs:
infos.append(info)
for info in infos:
# update fonts
import matplotlib.pylab as plt
params = {
'axes.titlesize': cfg.fontsdict_plot['fontsize'],
'xtick.labelsize': cfg.fontsdict_plot['fontsize'],
'ytick.labelsize': cfg.fontsdict_plot['fontsize']
}
plt.rcParams.update(params)
# select a specific info
selected_info_IDs = ['N1-19-9']
# open window to select nuclei criteria
loaded_infos = ImageHandler.load_image_infos()
infos = list()
for info in loaded_infos:
info_ID = info['ID']
if info_ID in selected_info_IDs:
infos.append(info)
for info in infos:
seg = Segmentation(info)
seg.load()
# go through nuclei and add them to a stack with
# nuclei_in_direction as value
nIDs = seg.nuclei.get_nIDs(only_accepted=True)
if opt == '-s':
processing['start'] = 1
elif opt == '-p':
processing['process'] = int(arg)
elif opt == '-m':
processing['merge'] = int(arg)
elif opt == '-n':
processing['nuclei'] = int(arg)
elif opt == '-c':
processing['select'] = int(arg)
else:
selected_info_ID = None
processing['start'] = 1
# load infos
infos = ImageHandler.load_image_infos()
selected_info = None
for info in infos:
if info['ID'] == selected_info_ID:
selected_info = info
# start
if processing['start'] == 1:
exp_id = None
if selected_info_ID is not None:
exp_id = selected_info_ID
test_window = NucleoSegment(exp_id=exp_id)
test_window.show()
test_window.raise_()
# show the editor to choose images
app = QtGui.QApplication(sys.argv)
# update fonts
import matplotlib.pylab as plt
params = {'axes.titlesize': cfg.fontsdict_plot['fontsize'],
'xtick.labelsize': cfg.fontsdict_plot['fontsize'],
'ytick.labelsize': cfg.fontsdict_plot['fontsize']}
plt.rcParams.update(params)
selected_info_IDs = ['N1-19-9', 'N1-19-22', 'N1-19-23', 'N1-19-24']
#selected_info_IDs = ['N1-19-9']
# open window to select nuclei criteria
loaded_infos = ImageHandler.load_image_infos()
infos = list()
for info in loaded_infos:
info_ID = info['ID']
if info_ID in selected_info_IDs:
infos.append(info)
for info in infos:
seg = Segmentation(info)
seg.load()
print('LOAD', info['ID'])
# go through nuclei and add to stack
nIDs = seg.nuclei.get_nIDs(only_accepted=True)
def show_nucleus_box(fig,
nucleus_boxes,
nucleus_centroids,
nucleus_areas,
stacks,
reload=False):
"""
Show a nucleus in a box
:param fig:
:param nID:
:param nucleus_boxes:
:param stacks:
:return:
"""
stack_boxes = Plot.get_nucleus_boxes(nucleus_boxes,
nucleus_centroids,
nucleus_areas,
stacks,
reload=reload)
# calculate overlays
overlay_xy = nucleus_boxes['crop_rgb'][
round(nucleus_boxes['crop_rgb'].shape[0] / 2), :, :].copy()
overlay_zx = nucleus_boxes['crop_rgb'][:,
round(nucleus_boxes['crop_rgb'].
shape[1] / 2), :].copy()
overlay_zy = ImageHandler.transform_rgb_img(
nucleus_boxes['crop_rgb']
[:, :, round(nucleus_boxes['crop_rgb'].shape[2] / 2)].copy())
# xy image
ax_xy = fig.add_subplot(111)
ax_xy.imshow(stack_boxes.lamin[round(stack_boxes.lamin.shape[0] / 2)],
cmap='gray')
ax_xy.imshow(overlay_xy,
cmap=cfg.nucleus_select_corr_nuclei_overlay_colour,
alpha=cfg.nucleus_select_corr_nuclei_overlay_alpha)
divider = make_axes_locatable(ax_xy)
axes_size = 2.5
# zx projection
ax_zx = divider.append_axes("bottom", axes_size, pad=0.2, sharex=ax_xy)
ax_zx.imshow(stack_boxes.lamin[:,
round(stack_boxes.lamin.shape[1] /
2), :],
cmap='gray')
ax_zx.imshow(overlay_zx,
cmap=cfg.nucleus_select_corr_nuclei_overlay_colour,
alpha=cfg.nucleus_select_corr_nuclei_overlay_alpha)
ax_zx.set_ylim([stack_boxes.lamin.shape[0], 0])
# zy projection
ax_zy = divider.append_axes("right", axes_size, pad=0.2, sharey=ax_xy)
ax_zy.imshow(stack_boxes.lamin[:, :,
round(stack_boxes.lamin.shape[2] /
2)].T,
cmap='gray')
ax_zy.imshow(overlay_zy,
cmap=cfg.nucleus_select_corr_nuclei_overlay_colour,
alpha=cfg.nucleus_select_corr_nuclei_overlay_alpha)
ax_zy.set_xlim([0, stack_boxes.lamin.shape[0]])
return stack_boxes
import storage.config as cfg
# show the editor to choose images
app = QtGui.QApplication(sys.argv)
# update fonts
import matplotlib.pylab as plt
params = {'axes.titlesize': cfg.fontsdict_plot['fontsize'],
'xtick.labelsize': cfg.fontsdict_plot['fontsize'],
'ytick.labelsize': cfg.fontsdict_plot['fontsize']}
plt.rcParams.update(params)
# open window to select nuclei criteria
infos = ImageHandler.load_image_infos()
# select a specific info
selected_info_IDs = ['N1-19-24']
for info in infos:
if info['ID'] in selected_info_IDs:
seg = Segmentation(info)
seg.load()
processing_steps = [
['EQU'],
['THR', 'OTSU', 100, 'no3D'],
['CLS', 'bin', 2],
['FILL'],
['OPN', 'bin', 2],
else:
pouch_volumes.append(
ImageProcessing.apply_filters(processing_steps,
pouch_stack,
verbose=True))
results_titles.append('Processed')
# show images
stack_fig = plt.figure(figsize=(20, 10))
# view the stack and the processing results
results = list()
results.append(pouch_stack)
for pouch_volume in pouch_volumes:
results.append(pouch_volume)
cmap = list()
for i in range(0, len(results)):
cmap.append('hot')
Plot.show_stacks(stack_fig,
results,
range(0, 4, 1),
img_title=results_titles,
colour_map=cmap)
ImageHandler.save_stack_as_tiff(pouch_volumes[0],
work_dir + 'pouch_volume.tif')
def __init__(self, image_info, silent_processing=False, parent=None):
super(NucleoProcess, self).__init__(parent)
# load image infos
self.image_info = image_info
# load image
image_stack = ImageHandler.load_image(image_info)
# focus on lamin signal
self.stacks = Stack()
self.stacks.lamin = image_stack[ImageHandler.CHN_LAMIN]
# init processing steps
self.processing_steps = list()
self.reset_processing_steps()
# build filtered list
self.stacks.filtered = list()
# apply filters
self.stacks.filtered.append(
[ImageProcessing.apply_filters(self.processing_steps, self.stacks.lamin)])
# edit boxes for range
self.edt_image_range_start = QtGui.QLineEdit()
self.edt_image_range_stop = QtGui.QLineEdit()
self.edt_image_range_int = QtGui.QLineEdit()
self.edt_image_zoom = QtGui.QLineEdit()
# calculate educated guesses for range take the middle
range_start = round(self.stacks.lamin.shape[0]/2) - cfg.image_processing_default_range_offset
range_stop = round(self.stacks.lamin.shape[0]/2) + cfg.image_processing_default_range_offset
if range_start < 0:
range_start = 0
if range_stop > self.stacks.lamin.shape[0]:
range_stop = self.stacks.lamin.shape[0]
self.image_range = range(range_start, range_stop,
cfg.image_processing_default_range_int)
self.image_int = cfg.image_processing_default_range_int
self.image_zoom = cfg.image_processing_default_zoom
# set layout for processing results
self.ctn_image_process_results = QtGui.QGridLayout()
# set combolist for filtering methods and the methods chosen
self.sel_image_process_steps = list()
self.filter_mapping = ImageProcessing.get_filter_mapping()
# buttons to submit processing steps
self.btn_image_process_reset = QtGui.QPushButton(gui_labels.btn_reset)
self.btn_image_process_load = QtGui.QPushButton(gui_labels.btn_load)
self.btn_image_process_save = QtGui.QPushButton(gui_labels.btn_save)
self.btn_image_process = QtGui.QPushButton(gui_labels.btn_process)
self.btn_close = QtGui.QPushButton(gui_labels.btn_close)
# set main layout
self.setLayout(self.prep_ctn_image_process())
# silent processing
if silent_processing is True:
# load processing steps
self.load_image_process_steps(False)
# process image
self.process_image()
else:
# load settings and apply
self.load_image_process_steps()
# show the editor to choose images
app = QtGui.QApplication(sys.argv)
# update fonts
import matplotlib.pylab as plt
params = {
'axes.titlesize': cfg.fontsdict_plot['fontsize'],
'xtick.labelsize': cfg.fontsdict_plot['fontsize'],
'ytick.labelsize': cfg.fontsdict_plot['fontsize']
}
plt.rcParams.update(params)
# open window to select nuclei criteria
infos = ImageHandler.load_image_infos()
# select a specific info
selected_info_IDs = ['N1-19-9', 'N1-19-23']
selected_infos = dict()
segs = dict()
# maps
density_map = dict()
volume_map = dict()
# lists
density_list = dict()
volume_list = dict()
min_den = -1
results_titles.append('Union')
# add union to filtered
pouch_volume_final = pouch_volume_filtered + union_pouch_volume
pouch_volume_final[pouch_volume_final > 1] = 1
#for i in range(20, 41, 5):
# final_steps[0][2] = i
# pouch_volumes.append(ImageProcessing.apply_filters(final_steps, pouch_volume_final, verbose=True))
# results_titles.append('CLS %i' % i)
pouch_volume_final = ImageProcessing.apply_filters(final_steps, pouch_volume_final, verbose=True)
results.append(pouch_volume_final)
results_titles.append('Volume #%i' % i)
if save_as_stack is True:
ImageHandler.save_stack_as_tiff(pouch_volume_final, work_dir + ('%s_pv.tif' % pouch_files[i]))
if show_stack is True:
# show images
stack_fig = plt.figure(figsize=(20, 10))
# view the stack and the processing results
cmap = list()
for i in range(0, len(results)):
cmap.append('hot')
Plot.show_stacks(stack_fig, results, show_range, img_title=results_titles, colour_map=cmap)
for layer_param in layers_to_get:
for layer_id in range(1, layers_to_get_count + 1):
params_to_get.append('layer_' + layer_param + '_' + str(layer_id))
limit_nvals = 5
save_csv = True
plot_figures = True
only_centre = True
# window tiling for averaging data
tiling_dim = 50
tiling_count = 5
tiling_offset = int(tiling_dim / tiling_count)
# open window to select nuclei criteria
loaded_infos = ImageHandler.load_image_infos()
infos = list()
for info in loaded_infos:
info_ID = info['ID']
if info_ID in selected_info_IDs:
infos.append(info)
print('TEST APPEND', info)
img_maps = dict()
val_maps = dict()
tiling_count_map = dict()
tiling_maps = dict()
limits = dict()
limit_lists = dict()
app = QtGui.QApplication(sys.argv)
# update fonts
import matplotlib.pylab as plt
params = {
'axes.titlesize': cfg.fontsdict_plot['fontsize'],
'xtick.labelsize': cfg.fontsdict_plot['fontsize'],
'ytick.labelsize': cfg.fontsdict_plot['fontsize']
}
plt.rcParams.update(params)
selected_info_IDs = ['N1-19-9', 'N1-19-22', 'N1-19-23', 'N1-19-24']
#selected_info_IDs = ['N1-19-9']
# open window to select nuclei criteria
loaded_infos = ImageHandler.load_image_infos()
infos = list()
for info in loaded_infos:
info_ID = info['ID']
if info_ID in selected_info_IDs:
infos.append(info)
for info in infos:
seg = Segmentation(info)
seg.load()
print('LOAD', info['ID'])
# go through nuclei and add to stack
nIDs = seg.nuclei.get_nIDs(only_accepted=True)