def predict(self):
#############################################
# apply classifiers and save images
#############################################
result_folder = os.path.join(self.imageFolder, 'result_segmentation')
if not os.path.exists(result_folder):
os.mkdir(result_folder)
flist_in = ioDT.get_image_list(self.imageFolder)
flist_in.sort()
for f_in in flist_in:
print('#' * 20 + '\nLoading', f_in, '...')
img = imread(f_in)
if len(img.shape) == 2:
img = np.expand_dims(img, 0)
if img.shape[-1] == np.min(img.shape):
img = np.moveaxis(img, -1, 0)
img = img[0]
print('Predicting image...')
pred, prob = predict.predict_image(
img,
self.classifier,
self.scaler,
sigmas=self.params['sigmas'],
new_shape_scale=self.params['down_shape'],
feature_mode=self.params['feature_mode'],
deep=self.deepModel.isChecked())
# remove objects at the border
negative = ndi.binary_fill_holes(pred == 0)
mask_pred = (pred == 1) * negative
edge_prob = ((2**16 - 1) * prob[2]).astype(np.uint16)
mask_pred = mask_pred.astype(np.uint8)
# save mask
parent, filename = os.path.split(f_in)
filename, file_extension = os.path.splitext(filename)
new_name = os.path.join(parent, 'result_segmentation',
filename + '_classifier' + file_extension)
imsave(new_name, pred, check_contrast=False)
# perform watershed
mask_final = predict.make_watershed(
mask_pred,
edge_prob,
new_shape_scale=self.params['down_shape'])
# save final mask
parent, filename = os.path.split(f_in)
filename, file_extension = os.path.splitext(filename)
new_name = os.path.join(parent, 'result_segmentation',
filename + '_watershed' + file_extension)
imsave(new_name, mask_final, check_contrast=False)
print('All images done!')
def create_GT_mask(model_folder):
### check that model and trainingset exist
if not os.path.exists(model_folder):
print('Warning!')
print(model_folder,':')
print('Model folder not created! Skipping this subfolder.')
return
trainingset_folder = os.path.join(model_folder,'trainingset')
if not os.path.exists(trainingset_folder):
print('Warning!')
print(model_folder,':')
print('Trainingset images not found! Skipping this subfolder.')
return
### load trainingset images and previously generated ground truth
flist_in = io.get_image_list(trainingset_folder, string_filter='_GT', mode_filter='exclude')
flist_in.sort()
flist_gt = io.get_image_list(trainingset_folder, string_filter='_GT', mode_filter='include')
flist_gt.sort()
### if no trainingset images in the folder, skip this subfolder
if len(flist_in) == 0:
print('\n\nWarning, no trainingset!','Selected "'+model_folder+'" but no trainingset *data* detected. Transfer some images in the "trainingset" folder.')
return
### if there are more trainingset than ground truth, promptuse to make mask
if len(flist_in)!=len(flist_gt):
print('\n\nWarning, trainingset incomplete!','Selected "'+model_folder+'" but not all masks have been created.\nPlease provide manually annotated masks.')
for f in flist_in:
fn,ext = os.path.splitext(f)
mask_name = fn+'_GT'+ext
if not os.path.exists(mask_name):
if not PyQt5.QtWidgets.QApplication.instance():
app = PyQt5.QtWidgets.QApplication(sys.argv)
else:
app = PyQt5.QtWidgets.QApplication.instance()
m = makeManualMask(f,subfolder='',fn=fn+'_GT'+ext,wsize = (2000,2000))
m.show()
app.exec_()
def __init__(self, imageFolder, parent=None, start=None, stop=None):
super(inspectionWindow_20max, self).__init__(parent)
self.imageFolder = imageFolder
self.folder, self.cond = os.path.split(self.imageFolder)
self.flist_in = io.get_image_list(self.imageFolder)
self.n_imgs = len(self.flist_in)
self.start = start
self.stop = stop
self.n_shown_max = self.stop - self.start
self.make()
feature_type = 'daisy' # 'daisy' or 'ilastik'
deep = False # True: deep learning with Multi Layer Perceptrons; False: Logistic regression
###############################################################################
if __name__ == '__main__':
for model_folder in model_folders:
print('-------------'+model_folder+'------------')
training_folder = os.path.join(model_folder, 'trainingset')
### load images
flist_in = ioDT.get_image_list(
training_folder,
string_filter='_GT',
mode_filter='exclude'
)
img_train = []
for f in flist_in:
img = imread(f)
if len(img.shape)==2:
img = np.expand_dims(img,0)
if img.shape[-1] == np.min(img.shape):
img = np.moveaxis(img, -1, 0)
img_train.append( img[0] )
## load ground truth
flist_gt = ioDT.get_image_list(
training_folder,
string_filter='_GT',
def generate_overview_finalMask(input_folder,
chosen,
saveFig=True,
downshape=1,
autoclose=False):
print('### Generating recap image at', input_folder)
flist_in = io.get_image_list(input_folder)
flist_in = [flist_in[i] for i in range(len(flist_in)) if chosen[i]]
segment_folder = os.path.join(input_folder, 'result_segmentation')
flist_ma = io.get_image_list(segment_folder, '_finalMask.tif', 'include')
n_img = len(flist_in)
ncols = 5
nrows = (n_img - 1) // 5 + 1
fig, ax = plt.subplots(figsize=(3 * ncols, 3 * nrows),
nrows=nrows,
ncols=ncols)
ax = ax.flatten()
# ### multiprocess
# file_names = [[flist_in[i],flist_ma[i]] for i in range(n_img)]
# N_cores = np.clip( int(0.8 * multiprocessing.cpu_count()),1,None )
# pool = multiprocessing.Pool(N_cores)
# data_list = list( tqdm.tqdm(
# pool.istarmap(
# ImageTools.io.load_images_ch0,
# zip( flist_in,
# flist_ma,
# repeat( downshape ) ) ),
# total = n_img ) )
# imgs = [data[0] for data in data_list]
# masks = [data[1] for data in data_list]
### normal for loop
imgs = [0. for i in range(n_img)]
masks = [0. for i in range(n_img)]
for i in tqdm.tqdm(range(n_img)):
img = imread(flist_in[i]).astype(float)
if len(img.shape) == 2:
img = np.expand_dims(img, 0)
if img.shape[-1] == np.min(img.shape):
img = np.moveaxis(img, -1, 0)
imgs[i] = img[0, ::downshape, ::downshape]
masks[i] = imread(flist_ma[i])[::downshape, ::downshape].astype(float)
### plotting
for i in tqdm.tqdm(range(n_img)):
_, filename = os.path.split(flist_in[i])
filename, _ = os.path.splitext(filename)
ax[i].imshow(imgs[i],
'gray',
interpolation='none',
vmin=np.percentile(img, 1.),
vmax=np.percentile(img, 99.))
cmap = mpl.colors.LinearSegmentedColormap.from_list(
'my_cmap', ['black', 'aqua'], 256)
ax[i].imshow(masks[i], cmap=cmap, interpolation='none', alpha=.3)
ax[i].set_title(("\n".join(wrap(filename, 20))), fontsize=6)
for a in ax:
a.axis('off')
for j in range(i + 1, len(ax)):
ax[j].remove()
# plt.show()
if autoclose:
plt.pause(10)
plt.close()
if saveFig:
print('### Saving image...')
# save figure
_, cond = os.path.split(input_folder)
fig.savefig(os.path.join(input_folder, 'result_segmentation',
cond + '_finalMasks.png'),
dpi=300)
print('### Done saving!')
return fig
def computeMaskForAll(self):
self.read_segmentation_params()
save_folder = os.path.join(self.imageFolder, 'result_segmentation')
folder, cond = os.path.split(self.imageFolder)
#############################################
# clean masks previously generated
#############################################
flist_to_remove = io.get_image_list(save_folder, '_finalMask',
'include')
for f in flist_to_remove:
os.remove(f)
segm_params = os.path.join(save_folder, 'segmentation_params.csv')
if os.path.exists(segm_params):
os.remove(segm_params)
morpho_file = os.path.join(save_folder, cond + '_morpho_params.json')
if os.path.exists(morpho_file):
os.remove(morpho_file)
#############################################
# save parameters used to make segmentation
#############################################
ioSeg.save_segmentation_params(
save_folder, [os.path.split(fin)[-1]
for fin in self.flist_in], self.chosen_masks,
self.down_shapes, self.thinnings, self.smoothings)
#############################################
# generate final mask
#############################################
print('### Generating the smoothened masks.')
for i in tqdm.tqdm(range(self.n_imgs)):
folder, filename = os.path.split(self.flist_in[i])
filename, extension = os.path.splitext(filename)
# print(i, filename)
if self.chosen_masks[i] == 'w':
_rawmask = imread(
os.path.join(self.imageFolder, 'result_segmentation',
filename + '_watershed' + extension))
mask = segment.smooth_mask(_rawmask,
mode='watershed',
down_shape=self.down_shapes[i],
smooth_order=self.smoothings[i])
while (np.sum(mask) == 0) & (self.smoothings[i] > 5):
print('Mask failed...')
# if mask is zero, try smoothing less
self.smoothings[i] -= 2
print('Trying with: smoothing', self.smoothings[i])
mask = segment.smooth_mask(_rawmask,
mode='watershed',
down_shape=self.down_shapes[i],
smooth_order=self.smoothings[i])
elif self.chosen_masks[i] == 'c':
_rawmask = imread(
os.path.join(self.imageFolder, 'result_segmentation',
filename + '_classifier' + extension))
mask = segment.smooth_mask(_rawmask,
mode='classifier',
down_shape=self.down_shapes[i],
smooth_order=self.smoothings[i],
thin_order=self.thinnings[i])
while (np.sum(mask) == 0) & (self.smoothings[i] >
5) & (self.thinnings[i] > 1):
print('Mask failed...')
# if mask is zero, try smoothing less
self.smoothings[i] -= 2
self.thinnings[i] -= 1
print('Trying with: smoothing', self.smoothings[i],
' thinnings', self.thinnings[i])
mask = segment.smooth_mask(_rawmask,
mode='classifier',
down_shape=self.down_shapes[i],
smooth_order=self.smoothings[i],
thin_order=self.thinnings[i])
elif self.chosen_masks[i] == 'm':
if not os.path.exists(
os.path.join(self.imageFolder, 'result_segmentation',
filename + '_manual' + extension)):
self.m = GUIs.manualmask.makeManualMask(self.flist_in[i])
self.m.show()
self.m.exec()
else:
print('A previously generated manual mask exists!')
_rawmask = imread(
os.path.join(self.imageFolder, 'result_segmentation',
filename + '_manual' + extension))
mask = segment.smooth_mask(_rawmask,
mode='manual',
down_shape=self.down_shapes[i],
smooth_order=self.smoothings[i])
while (np.sum(mask) == 0) & (self.smoothings[i] > 5):
print('Mask failed...')
# if mask is zero, try smoothing less
self.smoothings[i] -= 2
print('Trying with: smoothing', self.smoothings[i])
# if mask is zero, try smoothing less
self.smoothings[i] -= 2
mask = segment.smooth_mask(_rawmask,
mode='manual',
down_shape=self.down_shapes[i],
smooth_order=self.smoothings[i])
elif self.chosen_masks[i] == 'i':
continue
if np.sum(mask) == 0:
QMessageBox.warning(
self, 'Warning, no trainingset!',
'The method selected didn\'t generate a valid mask. Please input the mask manually.'
)
self.chosen_masks[i] = 'm'
ioSeg.save_segmentation_params(
save_folder,
[os.path.split(fin)[-1]
for fin in self.flist_in], self.chosen_masks,
self.down_shapes, self.thinnings, self.smoothings)
if not os.path.exists(
os.path.join(self.imageFolder, 'result_segmentation',
filename + '_manual' + extension)):
self.m = GUIs.manualmask.makeManualMask(self.flist_in[i])
self.m.show()
self.m.exec()
else:
print('A previously generated manual mask exists!')
_rawmask = imread(
os.path.join(self.imageFolder, 'result_segmentation',
filename + '_manual' + extension))
mask = segment.smooth_mask(_rawmask,
mode='manual',
down_shape=self.down_shapes[i],
smooth_order=self.smoothings[i])
ioSeg.save_segmentation_params(
save_folder, [os.path.split(fin)[-1]
for fin in self.flist_in], self.chosen_masks,
self.down_shapes, self.thinnings, self.smoothings)
# save final mask
new_name = os.path.join(folder, 'result_segmentation',
filename + '_finalMask' + extension)
imsave(new_name, mask)
print('### Done computing masks!')
#############################################
# compute morphology
#############################################
# props = DatasetTools.morphology.computemorphology.compute_morphological_info(self.imageFolder, self.compute_meshgrid.isChecked())
# DatasetTools.morphology.io.save_morpho_params(save_folder, cond, props)
#############################################
# generate recap
#############################################
w = overview.generate_overview_finalMask(
self.imageFolder,
chosen=[c != 'i' for c in self.chosen_masks],
saveFig=True,
downshape=3)
w.show()
def trainModel(self, archBox):
self.read_and_check_params()
#############################################
# load images to be used as training set
#############################################
training_folder = os.path.join(self.modelFolder, 'trainingset')
flist_in = ioDT.get_image_list(training_folder,
string_filter='_GT',
mode_filter='exclude')
img_train = []
for f in flist_in:
img = imread(f)
if len(img.shape) == 2:
img = np.expand_dims(img, 0)
if img.shape[-1] == np.min(img.shape):
img = np.moveaxis(img, -1, 0)
img_train.append(img[0])
# img_train = np.array(img_train)
flist_gt = ioDT.get_image_list(training_folder,
string_filter='_GT',
mode_filter='include')
gt_train = [imread(f) for f in flist_gt]
gt_train = [g.astype(int) for g in gt_train]
print('##### Training set:')
for i, f in enumerate(zip(flist_in, flist_gt)):
print(i + 1, '\t',
os.path.split(f[0])[-1], '\t',
os.path.split(f[1])[-1])
#############################################
# compute features and generate training set and weights
#############################################
print('##### Generating training set...')
X, Y, w, self.scaler = train.generate_training_set(
img_train, [g.astype(np.uint8) for g in gt_train],
sigmas=self.params['sigmas'],
down_shape=self.params['down_shape'],
edge_size=self.params['edge_size'],
fraction=self.params['fraction'],
feature_mode=self.params['feature_mode'],
bias=self.params['bias'])
#############################################
# Train the model
#############################################
print('##### Training model...')
start = time.time()
self.classifier = train.train_classifier(
X, Y, w, deep=self.deepModel.isChecked(), hidden=(350, 50))
print('Models trained in %.3f seconds.' % (time.time() - start))
# print('classes_: ', self.classifier.classes_)
# print('coef_: ', self.classifier.coef_)
#############################################
# Save the model
#############################################
ioML.save_model(self.modelFolder,
self.classifier,
self.scaler,
sigmas=self.params['sigmas'],
down_shape=self.params['down_shape'],
edge_size=self.params['edge_size'],
fraction=self.params['fraction'],
feature_mode=self.params['feature_mode'],
bias=self.params['bias'],
deep=self.deepModel.isChecked())
print('##### Model saved!')
self.predictButton.setEnabled(True)
def selectModelFolder(self):
self.modelFolder = QFileDialog.getExistingDirectory(
self, "Select Input Folder of Model")
# check if a trainingset is present
# a trainingset needs to exist for every model, even if the model is already trained.
trainingset_folder = os.path.join(self.modelFolder, 'trainingset')
if os.path.exists(trainingset_folder):
flist_in = ioDT.get_image_list(trainingset_folder,
string_filter='_GT',
mode_filter='exclude')
flist_in.sort()
flist_gt = ioDT.get_image_list(trainingset_folder,
string_filter='_GT',
mode_filter='include')
flist_gt.sort()
if len(flist_in) == 0:
QMessageBox.warning(
self, 'Warning, no trainingset!',
'Selected "' + self.modelFolder +
'" but no trainingset *data* detected. Transfer some images in the "trainingset" folder.'
)
self.modelFolder = '-'
return
if len(flist_in) != len(flist_gt):
QMessageBox.warning(
self, 'Warning, trainingset incomplete!',
'Selected "' + self.modelFolder +
'" but not all masks have been created.\nPlease provide manually annotated masks.'
)
for f in flist_in:
fn, ext = os.path.splitext(f)
mask_name = fn + '_GT' + ext
if not os.path.exists(mask_name):
m = manualmask.makeManualMask(f,
subfolder='',
fn=fn + '_GT' + ext)
# m.setModal(True)
m.show()
m.exec()
# self.modelFolder = '-'
# return
else:
QMessageBox.warning(
self, 'Warning, no trainingset!', 'Selected "' +
self.modelFolder + '" but no "trainingset" folder detected.')
self.modelFolder = '-'
return
# check if the model is already trained.
# if not, only allow training button
model_file = os.path.join(self.modelFolder, 'scaler.pkl')
if not os.path.exists(model_file):
QMessageBox.warning(
self, 'Warning, train model!',
'Train the model before loading!\nSetting default parameters...'
)
else:
self.loadModel()
if self.classifier is None:
return
self.predictButton.setEnabled(True)
self.recapButton.setEnabled(True)
self.inspectButton.setEnabled(True)
self.modelFolderSpace.setText(self.modelFolder)
self.set_params()
self.sigmasSpace.setEnabled(True)
self.down_shapeSpace.setEnabled(True)
self.edge_sizeSpace.setEnabled(True)
self.fractionSpace.setEnabled(True)
self.biasSpace.setEnabled(True)
self.feature_modeSpace.setEnabled(True)
self.trainButton.setEnabled(True)
def generate_overview(input_folder,
saveFig=True,
fileName='',
start=None,
stop=None,
downshape=1):
print('Generating recap image at', input_folder)
flist_in = io.get_image_list(input_folder)
segment_folder = os.path.join(input_folder, 'result_segmentation')
flist_ws = io.get_image_list(segment_folder, '_watershed.tif', 'include')
flist_cl = io.get_image_list(segment_folder, '_classifier.tif', 'include')
if start == None: start = 0
if stop == None: stop = len(flist_in)
flist_in = flist_in[start:stop]
flist_ws = flist_ws[start:stop]
flist_cl = flist_cl[start:stop]
n_img = len(flist_in)
ncols = 5
nrows = (n_img - 1) // 5 + 1
# ### multiprocess
# file_names = [[flist_in[i],flist_cl[i],flist_ws[i]] for i in range(n_img)]
# N_cores = np.clip( int(0.8 * multiprocessing.cpu_count()),1,None )
# pool = multiprocessing.Pool(N_cores)
# data_list = list( tqdm.tqdm(
# pool.istarmap(
# ImageTools.io.load_images_ch0,
# zip( file_names,
# repeat( downshape ) ) ),
# total = n_img ) )
# imgs = [data[0] for data in data_list]
# classifiers = [data[1] for data in data_list]
# watersheds = [data[2] for data in data_list]
### normal for loop
imgs = [0. for i in range(n_img)]
classifiers = [0. for i in range(n_img)]
watersheds = [0. for i in range(n_img)]
for i in tqdm.tqdm(range(n_img)):
img = imread(flist_in[i]).astype(float)
if img.ndim == 2:
img = np.expand_dims(img, 0)
if img.shape[-1] == np.min(img.shape):
img = np.moveaxis(img, -1, 0)
imgs[i] = img[0, ::downshape, ::downshape]
classifiers[i] = imread(
flist_cl[i])[::downshape, ::downshape].astype(float)
watersheds[i] = imread(
flist_ws[i])[::downshape, ::downshape].astype(float)
### plotting
fig, ax = plt.subplots(figsize=(3 * ncols, 3 * nrows),
nrows=nrows,
ncols=ncols)
ax = ax.flatten()
for i in tqdm.tqdm(range(n_img)):
_, filename = os.path.split(flist_in[i])
filename, _ = os.path.splitext(filename)
ax[i].imshow(imgs[i],
'gray',
interpolation='none',
vmin=np.percentile(img, 1.),
vmax=np.percentile(img, 99.))
cmap = mpl.colors.LinearSegmentedColormap.from_list(
'my_cmap', ['black', 'red'], 256)
ax[i].imshow(classifiers[i], cmap=cmap, interpolation='none', alpha=.4)
cmap = mpl.colors.LinearSegmentedColormap.from_list(
'my_cmap', ['black', 'aqua'], 256)
ax[i].imshow(watersheds[i], cmap=cmap, interpolation='none', alpha=.3)
ax[i].set_title("\n".join(wrap(filename, 20)), fontsize=8)
for a in ax:
a.axis('off')
for j in range(i + 1, len(ax)):
ax[j].remove()
# plt.show()
if saveFig:
print('Saving image...')
# save figure
_, cond = os.path.split(input_folder)
print(fileName)
if fileName == '':
fileName = os.path.join(input_folder, 'result_segmentation',
cond + '_recap_classifier.png')
fig.savefig(fileName, dpi=300)
print('Done saving!')
return fig
def parsing_images(image_folder,
mask_folder,
identifier_string,
objects_at_border=False):
# make directories if not already present
images_output_dir = os.path.join(image_folder, 'splitObjects')
masks_output_dir = os.path.join(images_output_dir, 'result_segmentation')
if not os.path.isdir(images_output_dir):
os.mkdir(images_output_dir)
if not os.path.isdir(masks_output_dir):
os.mkdir(masks_output_dir)
# read images and append if only one channel is present/only greyscale image
flist_in = io.get_image_list(image_folder,
string_filter=identifier_string,
mode_filter='exclude')
img_to_crop = []
for f in flist_in:
img = imread(f)
if img.ndim == 2:
img = np.expand_dims(img, 0)
if img.shape[-1] == np.min(img.shape):
img = np.moveaxis(img, -1, 0)
img_to_crop.append(img)
# read masks/groundtruth
flist_mask = io.get_image_list(mask_folder,
string_filter=identifier_string,
mode_filter='include')
# check that number of masks = number of images, otherwise, find missing mask
if len(flist_in) != len(flist_mask):
for f_in in flist_in:
parent, filename = os.path.split(f_in)
filename, file_extension = os.path.splitext(filename)
mask_name = os.path.join(
image_folder, filename + identifier_string + file_extension)
if mask_name not in flist_mask:
print('\"' + mask_name + '\" not found!')
sys.exit(
'Please check that mask is present for every image in input folder!'
)
# read and convert masks
mask_to_crop = [imread(f) for f in flist_mask]
mask_to_crop = [g.astype(int) for g in mask_to_crop]
for i in range(len(mask_to_crop)):
region_counter = 0
# label mask
labeled_mask, num_features = label(mask_to_crop[i], return_num=True)
# for saving of cropped regions
parent, filename = os.path.split(flist_in[i])
filename, file_extension = os.path.splitext(filename)
img_new_name = os.path.join(
masks_output_dir, filename + "_cropped_mask" + file_extension)
for region in measure.regionprops(labeled_mask):
# compute coordinates of regions
[min_row, min_col, max_row, max_col] = region.bbox
# exclude objects at edge if required
if not objects_at_border:
if min_row == 0 or min_col == 0 or \
max_row == labeled_mask.shape[0] or max_row == labeled_mask.shape[1]:
# leave cropped objects_at_border in a different folder
border_objects_output_dir = os.path.join(
images_output_dir, 'objects_at_image_border')
if not os.path.isdir(border_objects_output_dir):
os.mkdir(border_objects_output_dir)
cropped_mask = mask_to_crop[i][min_row:max_row,
min_col:max_col]
cropped_img = img_to_crop[i][:, min_row:max_row,
min_col:max_col]
# save cropped regions
img_new_name = os.path.join(
border_objects_output_dir, filename +
"_cropped%02d" % region_counter + file_extension)
mask_new_name = os.path.join(
border_objects_output_dir,
filename + "_cropped%02d_finalMask" % region_counter +
file_extension)
imsave(mask_new_name, cropped_mask.astype(np.uint8))
imsave(img_new_name, cropped_img)
region_counter += 1
continue
# crop images and masks based on coordinates of regions in mask
cropped_mask = mask_to_crop[i][min_row:max_row, min_col:max_col]
cropped_img = img_to_crop[i][:, min_row:max_row, min_col:max_col]
# save cropped regions
img_new_name = os.path.join(
images_output_dir,
filename + "_cropped%02d" % region_counter + file_extension)
mask_new_name = os.path.join(
masks_output_dir, filename +
"_cropped%02d_finalMask" % region_counter + file_extension)
imsave(mask_new_name, cropped_mask.astype(np.uint8))
imsave(img_new_name, cropped_img)
region_counter += 1
# save parameters
flist_cropped_images = io.get_image_list(images_output_dir)
filenames = [os.path.split(fin)[1] for fin in flist_cropped_images]
chosen_mask = 'user input'
down_shape = 0.5
thinning = smoothing = 'N.A.'
ioSeg.save_segmentation_params(masks_output_dir, filenames, chosen_mask,
down_shape, thinning, smoothing)
# compute morphological information
# props = computemorphology.compute_morphological_info(
# images_output_dir, compute_meshgrid=False)
# ioMorph.save_morpho_params(masks_output_dir, 'splitObjects', props)
print('Done!')
return
image_folders = [g for g in folder_names if not g in model_folders_name + exclude_folder]
image_folders = [os.path.join(parent_folder, i) for i in image_folders]
###############################################################################
if __name__ == '__main__':
app = PyQt5.QtWidgets.QApplication(sys.argv)
for image_folder in image_folders:
### compute parent folder as absolute path
image_folder = os.path.abspath(image_folder)
print('\n-------------'+image_folder+'------------\n')
flist_in = ioDT.get_image_list(image_folder)
n_imgs = len( flist_in )
if os.path.exists(os.path.join(image_folder,'result_segmentation','segmentation_params.csv')):
flist_in, chosen_masks, down_shapes, thinnings, smoothings = ioSeg.load_segmentation_params( os.path.join(image_folder,'result_segmentation') )
flist_in = [os.path.join(image_folder,i) for i in flist_in]
else:
chosen_masks = ['w' for i in range(n_imgs)]
down_shapes = [0.50 for i in range(n_imgs)]
thinnings = [10 for i in range(n_imgs)]
smoothings = [25 for i in range(n_imgs)]
save_folder = os.path.join(image_folder, 'result_segmentation')
ioSeg.save_segmentation_params( save_folder,
[os.path.split(fin)[-1] for fin in flist_in],
chosen_masks,
down_shapes,
def compute_morphological_info(input_folder,
compute_meshgrid=False,
compute_locoefa=True):
'''
fdwafwvgrs
'''
print('### Computing morphology of images in:', input_folder)
flist_all = io.get_image_list(input_folder)
masks_folder = os.path.join(input_folder, 'result_segmentation')
_, chosen_mask, down_shape, _, _ = ioSeg.load_segmentation_params(
masks_folder)
flist_in = [
flist_all[i] for i in range(len(flist_all)) if chosen_mask[i] != 'i'
]
flist_ma = io.get_image_list(masks_folder,
string_filter='_finalMask.tif',
mode_filter='include')
# measure region props for every mask
N_img = len(flist_in)
# multiprocess
N_cores = np.clip(int(0.8 * multiprocessing.cpu_count()), 1, None)
try:
# try using multiprocessing
df = pd.DataFrame({})
pool = multiprocessing.Pool(N_cores)
data_list = list(
tqdm.tqdm(pool.istarmap(
computemorphology.compute_morphological_info,
zip(repeat(None), flist_in, flist_ma, down_shape,
repeat(compute_meshgrid), repeat(compute_locoefa))),
total=N_img))
# print(data_list)
for row in data_list:
df = df.append(row, ignore_index=True)
except ValueError:
# if anything goes wrong, fall back to for loop processing
df = pd.DataFrame({})
for i in tqdm.tqdm(range(N_img)):
f_in, f_ma = flist_in[i], flist_ma[i]
mask = imread(f_ma)
# compute new row
row = computemorphology.compute_morphological_info(
mask,
f_in,
f_ma,
down_shape[i],
compute_meshgrid,
compute_locoefa=compute_locoefa)
# concatenate
df = df.append(row, ignore_index=True)
return df
