def aparse_params(dict_paths):
"""
SEE: https://docs.python.org/3/library/argparse.html
:return ({str: str}, obj):
"""
parser = argparse.ArgumentParser()
parser.add_argument(
'-annot',
'--path_annot',
type=str,
required=False,
help='path to directory with annotations & name pattern',
default=dict_paths['annot'])
parser.add_argument(
'-segm',
'--path_segm',
type=str,
required=False,
help='path to directory & name pattern for segmentation',
default=dict_paths['segm'])
parser.add_argument('-imgs',
'--path_image',
type=str,
required=False,
help='path to directory & name pattern for images',
default=dict_paths['image'])
parser.add_argument('-out',
'--path_out',
type=str,
required=False,
help='path to the output directory',
default=dict_paths['output'])
args = parser.parse_args()
logging.info('ARG PARAMETERS: \n %s', repr(args))
dict_paths = {
'annot': tl_data.update_path(args.path_annot),
'segm': tl_data.update_path(args.path_segm),
'image': '',
'output': tl_data.update_path(args.path_out),
}
if isinstance(args.path_image, str) and args.path_image.lower() != 'none':
dict_paths['image'] = tl_data.update_path(args.path_image)
for k in dict_paths:
if dict_paths[k] == '' or k == 'output':
continue
p = os.path.dirname(
dict_paths[k]) if '*' in dict_paths[k] else dict_paths[k]
assert os.path.exists(p), 'missing: (%s) "%s"' % (k, p)
return dict_paths, args
def arg_parse_params(params):
"""
SEE: https://docs.python.org/3/library/argparse.html
:return ({str: str}, int):
"""
parser = argparse.ArgumentParser()
parser.add_argument('-imgs', '--path_images', type=str, required=False,
help='path to directory & name pattern for images',
default=params['path_images'])
parser.add_argument('-segs', '--path_segms', type=str, required=False,
help='path to directory & name pattern for segmentation',
default=params['path_segms'])
parser.add_argument('-centers', '--path_centers', type=str, required=False,
help='path to directory & name pattern for centres',
default=params['path_centers'])
parser.add_argument('-info', '--path_infofile', type=str, required=False,
help='path to the global information file',
default=params['path_infofile'])
parser.add_argument('--stages', type=int, required=False, nargs='+',
help='stage indexes', default=[1, 2, 3, 4, 5])
parser.add_argument('-out', '--path_output', type=str, required=False,
help='path to the output directory',
default=params['path_output'])
parser.add_argument('--nb_jobs', type=int, required=False, default=NB_THREADS,
help='number of processes in parallel')
arg_params = vars(parser.parse_args())
params.update(arg_params)
for k in (k for k in params if 'path' in k):
params[k] = tl_data.update_path(params[k], absolute=True)
logging.info('ARG PARAMETERS: \n %s', repr(params))
return params
def parse_arg_params():
""" create simple arg parser with default values (input, results, dataset)
:return obj: argparse
"""
parser = argparse.ArgumentParser()
parser.add_argument('-imgs',
'--path_images',
type=str,
required=True,
help='path to dir with annot',
default=PATH_IMAGES)
parser.add_argument('--label',
type=int,
required=False,
nargs='+',
help='labels to be replaced',
default=[-1])
parser.add_argument('--nb_jobs',
type=int,
required=False,
help='number of jobs in parallel',
default=NB_THREADS)
args = vars(parser.parse_args())
p_dir = tl_data.update_path(os.path.dirname(args['path_images']))
assert os.path.isdir(p_dir), 'missing folder: %s' % args['path_images']
args['path_images'] = os.path.join(p_dir,
os.path.basename(args['path_images']))
logging.info(tl_expt.string_dict(args, desc='ARG PARAMETERS'))
return args
def arg_parse_params():
"""
SEE: https://docs.python.org/3/library/argparse.html
:return {str: str}:
"""
parser = argparse.ArgumentParser()
parser.add_argument(
'-annot',
'--path_annot',
type=str,
required=False,
help='path to directory & name pattern for annotations',
default=PATH_ANNOT)
parser.add_argument('-out',
'--path_out',
type=str,
required=False,
help='path to the output directory',
default=PATH_DATA)
parser.add_argument('-nb',
'--nb_comp',
type=int,
required=False,
help='number of component in Mixture model',
default=2)
params = vars(parser.parse_args())
for k in (k for k in params if 'path' in k):
params[k] = tl_data.update_path(params[k], absolute=True)
p = os.path.dirname(params[k]) if '*' in params[k] else params[k]
assert os.path.exists(p), 'missing: %s' % p
# load saved configuration
logging.info('ARG PARAMETERS: \n %s', repr(params))
return params
def arg_parse_params(dict_paths):
"""
SEE: https://docs.python.org/3/library/argparse.html
:return ({str: str}, int):
"""
parser = argparse.ArgumentParser()
parser.add_argument('-annot', '--path_annot', type=str, required=False,
help='annotations',
default=dict_paths['annot'])
parser.add_argument('-imgs', '--path_image', type=str, required=False,
help='path to directory & name pattern for images',
default=dict_paths['image'])
parser.add_argument('-out', '--path_output', type=str, required=False,
help='path to the output directory',
default=dict_paths['output'])
parser.add_argument('--padding', type=int, required=False,
help='crop padding [px]', default=25)
parser.add_argument('--mask', type=int, required=False,
help='mask by the segmentation', default=1)
parser.add_argument('-bg', '--background', type=int, required=False,
help='using background color', default=None, nargs='+')
parser.add_argument('--nb_jobs', type=int, required=False, default=NB_THREADS,
help='number of processes in parallel')
args = vars(parser.parse_args())
logging.info('ARG PARAMETERS: \n %s', repr(args))
dict_paths = {k.split('_')[-1]:
os.path.join(tl_data.update_path(os.path.dirname(args[k])),
os.path.basename(args[k]))
for k in args if k.startswith('path_')}
for k in dict_paths:
assert os.path.exists(os.path.dirname(dict_paths[k])), \
'missing (%s) "%s"' % (k, os.path.dirname(dict_paths[k]))
return dict_paths, args
def load_image(path_img, img_type=TYPES_LOAD_IMAGE[0]):
""" load image and annotation according chosen type
:param str path_img:
:param str img_type:
:return ndarray:
"""
path_img = tl_data.update_path(path_img)
assert os.path.isfile(path_img), 'missing: "%s"' % path_img
if img_type == '2d_split':
img, _ = tl_data.load_img_double_band_split(path_img)
assert img.ndim == 2, 'image dims: %s' % repr(img.shape)
# img = np.rollaxis(np.tile(img, (3, 1, 1)), 0, 3)
# if img.max() > 1:
# img = (img / 255.)
elif img_type == '2d_rgb':
img, _ = tl_data.load_image_2d(path_img)
# if img.max() > 1:
# img = (img / 255.)
elif img_type == '2d_segm':
img, _ = tl_data.load_image_2d(path_img)
if img.ndim == 3:
img = img[:, :, 0]
if ANNOT_RELABEL_SEQUENCE:
img, _, _ = segmentation.relabel_sequential(img)
else:
logging.error('not supported loading img_type: %s', img_type)
img = None
return img
def arg_parse_params(paths):
"""
SEE: https://docs.python.org/3/library/argparse.html
:return ({str: ...}, bool, int):
"""
parser = argparse.ArgumentParser()
parser.add_argument('--images',
type=str,
required=False,
help='path to directory & name pattern for images',
default=paths['images'])
parser.add_argument('--annots',
type=str,
required=False,
help='path to directory & name pattern for annotation',
default=paths['annots'])
parser.add_argument(
'--segments',
type=str,
required=False,
help='path to directory & name pattern for segmentation',
default=paths['segments'])
parser.add_argument('--centers',
type=str,
required=False,
help='path to directory & name pattern for centres',
default=paths['centers'])
parser.add_argument('--results',
type=str,
required=False,
help='path to the result directory',
default=paths['results'])
parser.add_argument('--nb_jobs',
type=int,
required=False,
default=NB_THREADS,
help='number of processes in parallel')
parser.add_argument('--visual',
required=False,
action='store_true',
default=False,
help='export visualisations')
arg_params = vars(parser.parse_args())
export_visual = arg_params['visual']
for k in (k for k in arg_params if k != 'nb_jobs' and k != 'visual'):
if not isinstance(arg_params[k],
str) or arg_params[k].lower() == 'none':
paths[k] = None
continue
paths[k] = tl_data.update_path(arg_params[k], absolute=True)
p = paths[k] if k == 'results' else os.path.dirname(paths[k])
assert os.path.exists(p), 'missing: %s' % p
logging.info('ARG PARAMETERS: \n %s', repr(paths))
return paths, export_visual, arg_params['nb_jobs']
def load_image_segm_center(idx_row, path_out=None, dict_relabel=None):
""" by paths load images and segmentation and weather centers exist,
load them if the path out is given r\draw visualisation of inputs
:param (int, DF:row) idx_row:
:param str path_out: path to output directory
:param {} dict_relabel:
:return (str, ndarray, ndarray, [[int, int]]):
"""
idx, row_path = idx_row
for k in ['path_image', 'path_segm', 'path_centers']:
row_path[k] = tl_data.update_path(row_path[k])
assert os.path.exists(row_path[k]), 'missing %s' % row_path[k]
idx_name = get_idx_name(idx, row_path['path_image'])
img_struc, img_gene = tl_data.load_img_double_band_split(
row_path['path_image'], im_range=None)
# img_rgb = np.array(Image.open(row_path['path_img']))
img_rgb = tl_data.merge_image_channels(img_struc, img_gene)
if np.max(img_rgb) > 1:
img_rgb = img_rgb / float(np.max(img_rgb))
seg_ext = os.path.splitext(os.path.basename(row_path['path_segm']))[-1]
if seg_ext == '.npz':
with np.load(row_path['path_segm']) as npzfile:
segm = npzfile[npzfile.files[0]]
if dict_relabel is not None:
segm = seg_lbs.merge_probab_labeling_2d(segm, dict_relabel)
else:
segm = tl_data.io_imread(row_path['path_segm'])
if dict_relabel is not None:
segm = seg_lbs.relabel_by_dict(segm, dict_relabel)
if row_path['path_centers'] is not None \
and os.path.isfile(row_path['path_centers']):
ext = os.path.splitext(os.path.basename(row_path['path_centers']))[-1]
if ext == '.csv':
centers = tl_data.load_landmarks_csv(row_path['path_centers'])
centers = tl_data.swap_coord_x_y(centers)
elif ext == '.png':
centers = tl_data.io_imread(row_path['path_centers'])
# relabel loaded segm into relevant one
centers = np.array(LUT_ANNOT_CENTER_RELABEL)[centers]
else:
logging.warning('not supported file format %s', ext)
centers = None
else:
centers = None
if is_drawing(path_out):
export_visual_input_image_segm(path_out, idx_name, img_rgb, segm,
centers)
return idx_name, img_rgb, segm, centers
def parse_arg_params():
""" create simple arg parser with default values (input, output, dataset)
:param dict_params: {str: ...}
:return obj: object argparse<in, out, ant, name>
"""
parser = argparse.ArgumentParser()
parser.add_argument('-imgs',
'--path_images',
type=str,
required=True,
help='path to the input images')
parser.add_argument('-segs',
'--path_segms',
type=str,
required=True,
help='path to the input segms')
parser.add_argument('-out',
'--path_output',
type=str,
required=True,
help='path to the output')
parser.add_argument('--nb_jobs',
type=int,
required=False,
help='number of jobs in parallel',
default=NB_THREADS)
args = parser.parse_args()
paths = dict(
zip(['images', 'segms', 'output'],
[args.path_images, args.path_segms, args.path_output]))
for k in paths:
if '*' in paths[k] or k == 'output':
p_dir = tl_data.update_path(os.path.dirname(paths[k]))
paths[k] = os.path.join(p_dir, os.path.basename(paths[k]))
else:
paths[k] = tl_data.update_path(paths[k])
p_dir = paths[k]
assert os.path.exists(p_dir), 'missing: %s' % paths[k]
return paths, args.nb_jobs
def parse_arg_params():
""" create simple arg parser with default values (input, results, dataset)
:return obj: argparse
"""
parser = argparse.ArgumentParser()
parser.add_argument('-imgs',
'--path_images',
type=str,
required=True,
help='path to dir with images',
default=PATH_INPUT)
parser.add_argument('-out',
'--path_out',
type=str,
required=True,
help='path to output dir',
default=PATH_OUTPUT)
parser.add_argument('-clrs',
'--path_colors',
type=str,
required=False,
help='json with colour-label dict',
default=None)
parser.add_argument('--nb_jobs',
type=int,
required=False,
help='number of jobs in parallel',
default=NB_THREADS)
args = vars(parser.parse_args())
for n in ['path_images', 'path_out']:
p_dir = tl_data.update_path(os.path.dirname(args[n]))
assert os.path.isdir(p_dir), 'missing: %s' % args[n]
args[n] = os.path.join(p_dir, os.path.basename(args[n]))
if args['path_colors'] is not None:
args['path_colors'] = tl_data.update_path(args['path_colors'])
logging.info(tl_expt.string_dict(args, desc='ARG PARAMETERS'))
return args
def arg_parse_params(dict_paths):
"""
SEE: https://docs.python.org/3/library/argparse.html
:return ({str: str}, int):
"""
parser = argparse.ArgumentParser()
parser.add_argument('-annot', '--path_annot', type=str, required=False,
help='annotations',
default=dict_paths['annot'])
parser.add_argument('-imgs', '--path_image', type=str, required=False,
help='path to directory & name pattern for images',
default=dict_paths['image'])
parser.add_argument('-out', '--path_out', type=str, required=False,
help='path to the output directory',
default=dict_paths['output'])
parser.add_argument('--padding', type=int, required=False,
help='crop padding [px]', default=25)
parser.add_argument('--mask', type=int, required=False,
help='mask by the segmentation', default=1)
parser.add_argument('-bg', '--background', type=int, required=False,
help='using background color', default=None, nargs='+')
parser.add_argument('--nb_jobs', type=int, required=False, default=NB_THREADS,
help='number of processes in parallel')
args = parser.parse_args()
logging.info('ARG PARAMETERS: \n %s', repr(args))
dict_paths = {
'annot': tl_data.update_path(args.path_annot),
'image': tl_data.update_path(args.path_image),
'output': tl_data.update_path(args.path_out),
}
for k in dict_paths:
if dict_paths[k] == '' or k == 'output':
continue
p = os.path.dirname(dict_paths[k]) \
if '*' in dict_paths[k] else dict_paths[k]
assert os.path.exists(p), 'missing (%s) "%s"' % (k, p)
return dict_paths, args
def get_image_path(name_img, path_base=PATH_IMAGES):
""" merge default image path and sample image
:param str name_img:
:return str:
>>> p = get_image_path(IMAGE_LENNA)
>>> os.path.isfile(p)
True
>>> os.path.basename(p)
'lena.png'
"""
path_img = os.path.join(path_base, name_img)
path_img = tl_data.update_path(path_img)
return path_img
def parse_arg_params():
""" create simple arg parser with default values (input, results, dataset)
:return obj: argparse
"""
parser = argparse.ArgumentParser()
parser.add_argument('-imgs',
'--path_images',
type=str,
required=True,
help='path to images',
default=PATH_IMAGES)
parser.add_argument('-out',
'--path_output',
type=str,
required=True,
help='path to output dir',
default=PATH_OUTPUT)
parser.add_argument('--label_old',
type=int,
required=False,
nargs='+',
help='labels to be replaced',
default=[0])
parser.add_argument('--label_new',
type=int,
required=False,
nargs='+',
help='new labels after replacing',
default=[0])
parser.add_argument('--nb_jobs',
type=int,
required=False,
help='number of jobs in parallel',
default=NB_THREADS)
args = vars(parser.parse_args())
for k in ['path_images', 'path_output']:
p_dir = tl_data.update_path(os.path.dirname(args[k]))
assert os.path.isdir(p_dir), 'missing folder: %s' % args[k]
args[k] = os.path.join(p_dir, os.path.basename(args[k]))
assert len(args['label_old']) == len(args['label_new']), \
'length of old (%i) and new (%i) labels should be same' \
% (len(args['label_old']), len(args['label_new']))
logging.info(tl_expt.string_dict(args, desc='ARG PARAMETERS'))
return args
def arg_parse_params(params):
"""
SEE: https://docs.python.org/3/library/argparse.html
:return {str: ...}:
"""
parser = argparse.ArgumentParser()
parser.add_argument('-imgs',
'--path_images',
type=str,
required=False,
help='path to directory & name pattern for images',
default=params.get('path_images', None))
parser.add_argument('-ells',
'--path_ellipses',
type=str,
required=False,
help='path to directory & name pattern for ellipses',
default=params.get('path_ellipses', None))
parser.add_argument('-info',
'--path_infofile',
type=str,
required=False,
help='path to the global information file',
default=params.get('path_infofile', None))
parser.add_argument('-out',
'--path_output',
type=str,
required=False,
help='path to the output directory',
default=params.get('path_output', None))
parser.add_argument('--nb_jobs',
type=int,
required=False,
default=NB_THREADS,
help='number of processes in parallel')
arg_params = vars(parser.parse_args())
params.update(arg_params)
for k in (k for k in params if 'path' in k and params[k] is not None):
params[k] = tl_data.update_path(params[k], absolute=True)
logging.info('ARG PARAMETERS: \n %s', repr(params))
return params
def arg_parse_params(params):
"""
SEE: https://docs.python.org/3/library/argparse.html
:return {str: ...}:
"""
parser = argparse.ArgumentParser()
parser.add_argument('-imgs', '--path_images', type=str, required=False,
help='path to directory & name pattern for image',
default=params['path_images'])
parser.add_argument('-segm', '--path_segms', type=str, required=False,
help='path to directory & name pattern for annotation',
default=params['path_segms'])
parser.add_argument('-out', '--path_out', type=str, required=False,
help='path to the output directory',
default=params['path_out'])
parser.add_argument('--img_type', type=str, required=False,
default=params['img_type'], choices=TYPES_LOAD_IMAGE,
help='type of image to be loaded')
parser.add_argument('--slic_size', type=int, required=False,
default=20, help='superpixels size')
parser.add_argument('--slic_regul', type=float, required=False,
default=0.25, help='superpixel regularization')
parser.add_argument('--slico', action='store_true', required=False,
default=False, help='using SLICO (ASLIC)')
parser.add_argument('--nb_jobs', type=int, required=False, default=NB_THREADS,
help='number of processes in parallel')
params = vars(parser.parse_args())
logging.info('ARG PARAMETERS: \n %s', repr(params))
for k in (k for k in params if 'path' in k):
params[k] = tl_data.update_path(params[k])
if k == 'path_out' and not os.path.isdir(params[k]):
params[k] = ''
continue
p = os.path.dirname(params[k]) if '*' in params[k] else params[k]
assert os.path.exists(p), 'missing: (%s) "%s"' % (k, p)
# if the config path is set load the it otherwise use default
return params
def parse_arg_params():
""" create simple arg parser with default values (input, results, dataset)
:return obj: argparse
"""
parser = argparse.ArgumentParser()
parser.add_argument('-imgs',
'--path_images',
type=str,
required=True,
help='path to dir with images',
default=PATH_IMAGES)
parser.add_argument('-m',
'--method',
type=str,
required=False,
help='method for quantisation color/position',
default='color',
choices=['color', 'position'])
parser.add_argument('-thr',
'--px_threshold',
type=float,
required=False,
help='percentage of pixels of a color to be removed',
default=THRESHOLD_INVALID_PIXELS)
parser.add_argument('--nb_jobs',
type=int,
required=False,
help='number of jobs in parallel',
default=NB_THREADS)
args = vars(parser.parse_args())
p_dir = tl_data.update_path(os.path.dirname(args['path_images']))
assert os.path.isdir(p_dir), 'missing folder: %s' % args['path_images']
args['path_images'] = os.path.join(p_dir,
os.path.basename(args['path_images']))
logging.info(tl_expt.string_dict(args, desc='ARG PARAMETERS'))
return args
import os
import sys
import glob
import logging
import pickle
import argparse
import numpy as np
import pandas as pd
sys.path += [os.path.abspath('.'), os.path.abspath('..')] # Add path to root
import imsegm.utils.data_io as tl_data
import imsegm.region_growing as tl_rg
PATH_DATA = tl_data.update_path('data_images', absolute=True)
PATH_IMAGES = os.path.join(tl_data.update_path('data_images'), 'drosophila_ovary_slice')
PATH_ANNOT = os.path.join(PATH_IMAGES, 'annot_eggs', '*.png')
RAY_STEP = 10
# names of default files for models
NAME_CSV_RAY_ALL = 'egg_ray_shapes.csv'
NAME_PKL_MODEL_SINGLE = 'RG2SP_single-model.pkl'
NAME_PKL_MODEL_MIXTURE = 'RG2SP_mixture-model.pkl'
NAME_NPZ_MODEL_SINGLE = 'RG2SP_single-model.npz'
NAME_NPZ_MODEL_MIXTURE = 'RG2SP_mixture-model.npz'
def arg_parse_params():
"""
SEE: https://docs.python.org/3/library/argparse.html
:return {str: str}:
def arg_parse_params(params):
""" argument parser from cmd
SEE: https://docs.python.org/3/library/argparse.html
:return {str: ...}:
"""
parser = argparse.ArgumentParser()
parser.add_argument('-l',
'--path_train_list',
type=str,
required=False,
help='path to the list of image',
default=params['path_train_list'])
parser.add_argument('-i',
'--path_predict_imgs',
type=str,
required=False,
help='path to folder & name pattern with new image',
default=params['path_predict_imgs'])
parser.add_argument('-o',
'--path_out',
type=str,
required=False,
help='path to the output directory',
default=params['path_out'])
parser.add_argument('-n',
'--name',
type=str,
required=False,
help='name of the experiment',
default=params['name'])
parser.add_argument('-cfg',
'--path_config',
type=str,
required=False,
help='path to the segmentation config',
default='')
parser.add_argument('--img_type',
type=str,
required=False,
default=params['img_type'],
choices=TYPES_LOAD_IMAGE,
help='type of image to be loaded')
parser.add_argument('--nb_classes',
type=int,
required=False,
help='number of classes for segmentation',
default=params.get('nb_classes', 2))
parser.add_argument('--nb_jobs',
type=int,
required=False,
help='number of processes in parallel',
default=NB_THREADS)
parser.add_argument('--visual',
required=False,
action='store_true',
help='export debug visualisations',
default=False)
parser.add_argument('--unique',
required=False,
action='store_true',
help='each experiment has uniques stamp',
default=EACH_UNIQUE_EXPERIMENT)
args = vars(parser.parse_args())
logging.info('ARG PARAMETERS: \n %s', repr(args))
for k in (k for k in args if 'path' in k):
if args[k] == '' or args[k] == 'none': continue
args[k] = tl_data.update_path(args[k])
p = os.path.dirname(args[k]) if k == 'path_predict_imgs' else args[k]
assert os.path.exists(p), 'missing: (%s) "%s"' % (k, p)
# args['visual'] = bool(args['visual'])
# if the config path is set load the it otherwise use default
if os.path.isfile(args.get('path_config', '')):
with open(args['path_config'], 'r') as fd:
config = json.load(fd)
params.update(config)
params.update(args)
return params
import numpy as np
import pandas as pd
sys.path += [os.path.abspath('.'), os.path.abspath('..')] # Add path to root
import imsegm.utils.data_io as tl_data
import imsegm.utils.experiments as tl_expt
import imsegm.utils.drawing as tl_visu
import imsegm.superpixels as seg_spx
import imsegm.labeling as seg_lbs
from run_segm_slic_model_graphcut import load_image
from run_segm_slic_model_graphcut import TYPES_LOAD_IMAGE
NB_THREADS = max(1, int(mproc.cpu_count() * 0.9))
PATH_IMAGES = tl_data.update_path(os.path.join('images', 'drosophila_ovary_slice'))
PATH_RESULTS = tl_data.update_path('results', absolute=True)
NAME_CSV_DISTANCES = 'measured_boundary_distances.csv'
PARAMS = {
'path_images': os.path.join(PATH_IMAGES, 'image', '*.jpg'),
'path_segms': os.path.join(PATH_IMAGES, 'annot_eggs', '*.png'),
'path_out': os.path.join(PATH_RESULTS, 'compute_boundary_distances'),
'img_type': '2d_gray',
}
def arg_parse_params(params):
"""
SEE: https://docs.python.org/3/library/argparse.html
:return {str: ...}:
"""
'fts_ray_types': [('up', [0])],
# 'fts_ray_types': [('up', [0]), ('down', [1])],
'fts_ray_closer': True,
'fts_ray_smooth': 0,
'pca_coef': None,
# 'pca_coef': 0.99,
'balance': 'unique',
'classif': 'RandForest',
# 'classif': 'SVM',
'nb_classif_search': 50,
'dict_relabel': None,
# 'dict_relabel': {0: [0], 1: [1], 2: [2, 3]},
'center_dist_thr': 50, # distance to from annotated center as a point
}
PATH_IMAGES = os.path.join(tl_data.update_path('images'),
'drosophila_ovary_slice')
PATH_RESULTS = tl_data.update_path('results', absolute=True)
CENTER_PARAMS.update({
'path_list':
os.path.join(PATH_IMAGES, 'list_imgs-segm-center-levels_short.csv'),
'path_images':
'',
'path_segms':
'',
'path_centers':
'',
# 'path_images': os.path.join(PATH_IMAGES, 'image', '*.jpg'),
# 'path_segms': os.path.join(PATH_IMAGES, 'segm', '*.png'),
# 'path_centers': os.path.join(PATH_IMAGES, 'center_levels', '*.png'),
'path_infofile':
def arg_parse_params(params):
"""
SEE: https://docs.python.org/3/library/argparse.html
:return {str: str}:
"""
parser = argparse.ArgumentParser()
parser.add_argument('-list',
'--path_list',
type=str,
required=False,
help='path to the list of image',
default=params['path_list'])
parser.add_argument('-out',
'--path_out',
type=str,
required=False,
help='path to the output directory',
default=params['path_out'])
parser.add_argument('-n',
'--name',
type=str,
required=False,
help='name of the experiment',
default='ovary')
parser.add_argument('-cfg',
'--path_config',
type=str,
required=False,
help='path to the configuration',
default=None)
parser.add_argument('--nb_jobs',
type=int,
required=False,
default=NB_THREADS,
help='number of processes in parallel')
parser.add_argument('-m',
'--methods',
type=str,
required=False,
nargs='+',
help='list of segment. methods',
default=None)
arg_params = vars(parser.parse_args())
params.update(arg_params)
if not isinstance(arg_params['path_config'], str) \
or arg_params['path_config'].lower() == 'none':
params['path_config'] = ''
else:
params['path_config'] = tl_data.update_path(params['path_config'])
assert os.path.isfile(params['path_config']), \
'missing file: %s' % params['path_config']
assert os.path.splitext(params['path_config'])[-1] == '.json', \
'"%s" should be JSON file' % params['path_config']
with open(params['path_config'], 'r') as fd:
data = json.load(fd)
params.update(data)
params.update(arg_params)
for k in (k for k in arg_params if 'path' in k):
if arg_params[k] is None: continue
params[k] = tl_data.update_path(arg_params[k], absolute=True)
assert os.path.exists(params[k]), 'missing: %s' % params[k]
# load saved configuration
logging.info('ARG PARAMETERS: \n %s', repr(params))
return params
import logging
import os
import sys
import unittest
import matplotlib.pyplot as plt
from scipy.misc import imresize
sys.path.append(os.path.abspath(os.path.join('..', '..'))) # Add path to root
import imsegm.utils.data_samples as d_spl
import imsegm.utils.data_io as tl_data
import imsegm.utils.drawing as tl_visu
import imsegm.pipelines as pipelines
import imsegm.descriptors as seg_fts
PATH_OUTPUT = tl_data.update_path('output', absolute=True)
# set default feature extracted from image
FEATURES_TEXTURE = seg_fts.FEATURES_SET_TEXTURE_SHORT
seg_fts.USE_CYTHON = False
def show_segm_results_2d(img, seg, path_dir, fig_name='test_segm_.png'):
""" show and expert segmentation results
:param ndarray img: input image
:param ndarray seg: resulting segmentation
:param str path_dir: path to the visualisations
:param str fig_name: figure name
"""
fig = tl_visu.figure_image_segm_results(img, seg)
path_fig = os.path.join(path_dir, fig_name)
def aparse_params(dict_paths):
"""
SEE: https://docs.python.org/3/library/argparse.html
:return ({str: str}, obj):
"""
parser = argparse.ArgumentParser()
parser.add_argument(
'-a',
'--path_annot',
type=str,
required=True,
help='path to directory with annotations & name pattern',
default=dict_paths['annot'])
parser.add_argument(
'-s',
'--path_segm',
type=str,
required=True,
help='path to directory & name pattern for segmentation',
default=dict_paths['segm'])
parser.add_argument('-i',
'--path_image',
type=str,
required=False,
help='path to directory & name pattern for images',
default=dict_paths['image'])
parser.add_argument('-o',
'--path_output',
type=str,
required=False,
help='path to the output directory',
default=dict_paths['output'])
parser.add_argument('--drop_labels',
type=int,
required=False,
nargs='*',
help='list of skipped labels from statistic')
parser.add_argument('--nb_jobs',
type=int,
required=False,
help='number of processes in parallel',
default=NB_THREADS)
parser.add_argument('--overlap',
type=float,
required=False,
help='alpha for segmentation',
default=0.2)
parser.add_argument('--relabel',
required=False,
action='store_true',
help='relabel to find label relations',
default=False)
parser.add_argument('--visual',
required=False,
action='store_true',
help='export visualisations',
default=False)
args = vars(parser.parse_args())
logging.info('ARG PARAMETERS: \n %s', repr(args))
if not isinstance(args['path_image'], str) \
or args['path_image'].lower() == 'none':
args['path_image'] = None
dict_paths = {
k.split('_')[-1]:
os.path.join(tl_data.update_path(os.path.dirname(args[k])),
os.path.basename(args[k]))
for k in args if k.startswith('path_') and args[k] is not None
}
for k in dict_paths:
assert os.path.isdir(os.path.dirname(dict_paths[k])), \
'missing: (%s) "%s"' % (k, os.path.dirname(dict_paths[k]))
if args['drop_labels'] is None:
args['drop_labels'] = []
return dict_paths, args
"""
import os
import logging
from PIL import Image
import numpy as np
import imsegm.utils.data_io as tl_data
SAMPLE_SEG_SIZE_2D_SMALL = (20, 10)
SAMPLE_SEG_SIZE_2D_NORM = (150, 100)
SAMPLE_SEG_NB_CLASSES = 3
SAMPLE_SEG_SIZE_3D_SMALL = (10, 5, 6)
PATH_IMAGES = tl_data.update_path('images')
IMAGE_LENNA = os.path.join('others', 'lena.png')
IMAGE_OBJECTS = os.path.join('synthetic', 'reference.jpg')
IMAGE_3CLS = os.path.join('textures', 'sample_rgb_3cls.jpg')
IMAGE_STAR_1 = os.path.join('see_starfish', 'star_nb1.jpg')
IMAGE_STAR_2 = os.path.join('see_starfish', 'stars_nb2.jpg')
IMAGE_HISTOL_CIMA = \
os.path.join('histology_CIMA', '29-041-Izd2-w35-CD31-3-les1.jpg')
IMAGE_HISTOL_FLAGSHIP = \
os.path.join('histology_Flagship', 'Case001_Cytokeratin.jpg')
IMAGE_DROSOPHILA_DISC = \
os.path.join('drosophila_disc', 'image', 'img_6.jpg')
ANNOT_DROSOPHILA_DISC = \
os.path.join('drosophila_disc', 'annot', 'img_6.png')
IMAGE_DROSOPHILA_OVARY_2D = \
os.path.join('drosophila_ovary_slice', 'image', 'insitu7545.jpg')
def image_segmentation(idx_row, params, debug_export=DEBUG_EXPORT):
""" image segmentation which prepare inputs (imsegm, centres)
and perform segmentation of various imsegm methods
:param (int, str) idx_row: input image and centres
:param {str: ...} params: segmentation parameters
:return str: image name
"""
_, row_path = idx_row
for k in dict(row_path):
if isinstance(k, str) and k.startswith('path_'):
row_path[k] = tl_data.update_path(row_path[k], absolute=True)
logging.debug('segmenting image: "%s"', row_path['path_image'])
name = os.path.splitext(os.path.basename(row_path['path_image']))[0]
img = load_image(row_path['path_image'])
# make the image like RGB
img_rgb = np.rollaxis(np.tile(img, (3, 1, 1)), 0, 3)
seg = load_image(row_path['path_segm'], 'segm')
assert img_rgb.shape[:2] == seg.shape, \
'image %s and segm %s do not match' \
% (repr(img_rgb.shape[:2]), repr(seg.shape))
if not os.path.isfile(row_path['path_centers']):
logging.warning('no center was detected for "%s"', name)
return name
centers = tl_data.load_landmarks_csv(row_path['path_centers'])
centers = tl_data.swap_coord_x_y(centers)
if len(centers) == 0:
logging.warning('no center was detected for "%s"', name)
return name
# img = seg / float(seg.max())
slic = seg_spx.segment_slic_img2d(img_rgb,
sp_size=params['slic_size'],
rltv_compact=params['slic_regul'])
path_segm = os.path.join(params['path_exp'], 'input', name + '.png')
export_draw_image_segm(path_segm, img_rgb, segm_obj=seg, centers=centers)
seg_simple = simplify_segm_3cls(seg)
path_segm = os.path.join(params['path_exp'], 'simple', name + '.png')
export_draw_image_segm(path_segm, seg_simple - 1.)
dict_segment = create_dict_segmentation(params, slic, seg, img, centers)
image_name = name + '.png'
centre_name = name + '.csv'
# iterate over segmentation methods and perform segmentation on this image
for method in dict_segment:
(fn, args) = dict_segment[method]
logging.debug(' -> %s on "%s"', method, name)
path_dir = os.path.join(params['path_exp'], method) # n.split('_')[0]
path_segm = os.path.join(path_dir, image_name)
path_centre = os.path.join(path_dir + DIR_CENTRE_POSIX, centre_name)
path_fig = os.path.join(path_dir + DIR_VISUAL_POSIX, image_name)
path_debug = os.path.join(path_dir + DIR_DEBUG_POSIX, name)
# assuming that segmentation may fail
try:
t = time.time()
if debug_export and 'rg2sp' in method:
os.mkdir(path_debug)
segm_obj, centers, dict_export = fn(*args,
debug_export=path_debug)
else:
segm_obj, centers, dict_export = fn(*args)
# also export ellipse params here or inside the segm fn
if dict_export is not None:
for k in dict_export:
export_partial(k, dict_export[k], path_dir, name)
logging.info('running time of %s on image "%s" is %d s',
repr(fn.__name__), image_name,
time.time() - t)
tl_data.io_imsave(path_segm, segm_obj.astype(np.uint8))
export_draw_image_segm(path_fig, img_rgb, seg, segm_obj, centers)
# export also centers
centers = tl_data.swap_coord_x_y(centers)
tl_data.save_landmarks_csv(path_centre, centers)
except Exception:
logging.error('segment fail for "%s" via %s with \n %s', name,
method, traceback.format_exc())
return name
import pandas as pd
import numpy as np
sys.path += [os.path.abspath('.'), os.path.abspath('..')] # Add path to root
import imsegm.utils.data_io as tl_data
import imsegm.utils.experiments as tl_expt
import imsegm.utils.drawing as tl_visu
# import segmentation.annotation as seg_annot
import imsegm.ellipse_fitting as ell_fit
NAME_CSV_RESULTS = 'info_ovary_images_ellipses.csv'
OVERLAP_THRESHOLD = 0.
NB_THREADS = max(1, int(mproc.cpu_count() * 0.8))
PATH_IMAGES = tl_data.update_path(
os.path.join('data_images', 'drosophila_ovary_slice'))
DEFAULT_PARAMS = {
'path_ellipses': os.path.join(PATH_IMAGES, 'ellipse_fitting', '*.csv'),
'path_infofile': os.path.join(PATH_IMAGES, 'info_ovary_images.txt'),
'path_output': tl_data.update_path('results', absolute=True),
}
def arg_parse_params(params):
"""
SEE: https://docs.python.org/3/library/argparse.html
:return {str: ...}:
"""
parser = argparse.ArgumentParser()
parser.add_argument('-imgs',
def arg_parse_params(params):
"""
SEE: https://docs.python.org/3/library/argparse.html
:return {str: ...}:
"""
parser = argparse.ArgumentParser()
parser.add_argument('-list',
'--path_list',
type=str,
required=False,
help='path to the list of input files',
default=params['path_list'])
parser.add_argument('-imgs',
'--path_images',
type=str,
required=False,
help='path to directory & name pattern for images',
default=params['path_images'])
parser.add_argument(
'-segs',
'--path_segms',
type=str,
required=False,
help='path to directory & name pattern for segmentation',
default=params['path_segms'])
parser.add_argument('-centers',
'--path_centers',
type=str,
required=False,
help='path to directory & name pattern for centres',
default=params['path_centers'])
parser.add_argument('-info',
'--path_infofile',
type=str,
required=False,
help='path to the global information file',
default=params['path_infofile'])
parser.add_argument('-out',
'--path_output',
type=str,
required=False,
help='path to the output directory',
default=params['path_output'])
parser.add_argument('-n',
'--name',
type=str,
required=False,
help='name of the experiment',
default='ovary')
parser.add_argument('-config',
'--path_config',
type=str,
required=False,
help='path to the configuration',
default=None)
parser.add_argument('--nb_jobs',
type=int,
required=False,
default=NB_THREADS,
help='number of processes in parallel')
params.update(vars(parser.parse_args()))
paths = {}
for k in (k for k in params if 'path' in k):
if not isinstance(params[k], str) or params[k].lower() == 'none':
paths[k] = ''
continue
if '*' in params[k] or k == 'path_expt':
p_dir = tl_data.update_path(os.path.dirname(params[k]))
paths[k] = os.path.join(p_dir, os.path.basename(params[k]))
else:
paths[k] = tl_data.update_path(params[k], absolute=True)
p_dir = paths[k]
assert os.path.exists(p_dir), 'missing (%s) %s' % (k, p_dir)
# load saved configuration
if params['path_config'] is not None:
assert os.path.splitext(params['path_config'])[-1] == '.json', \
'wrong extension for %s' % params['path_config']
with open(params['path_config'], 'r') as fd:
data = json.load(fd)
params.update(data)
params.update(paths)
logging.info('ARG PARAMETERS: \n %s', repr(params))
return params
import matplotlib.pylab as plt
from scipy import ndimage, spatial
# from planar import line as pl_line
import matplotlib
matplotlib.use('GTKAgg') # or >> matplotlib.rcsetup.all_backends
# http://matplotlib.org/users/navigation_toolbar.html
import gtk
from matplotlib.figure import Figure
from matplotlib.backends.backend_gtkagg import FigureCanvasGTKAgg
sys.path += [os.path.abspath('.'), os.path.abspath('..')] # Add path to root
import imsegm.utils.data_io as tl_data
import imsegm.utils.drawing as tl_visu
PATH_BASE = tl_data.update_path(
os.path.join('data_images', 'drosophila_ovary_slice'))
PATH_IMAGES = os.path.join(PATH_BASE, 'image', '*.jpg')
PATH_CSV = os.path.join(PATH_BASE, 'center_levels', '*.csv')
NAME_INFO_SHORT = 'ovary_image_info.csv'
POSIX_CSV_LABEL = '_labeled'
COLUMNS_POSITION = ['ant_x', 'ant_y', 'post_x', 'post_y', 'lat_x', 'lat_y']
DICT_LIMIT_CORRECT = 10
DICT_LIMIT_REMOVE = 30
COLOR_FALSE_POSITIVE = '#FF5733'
COLOR_FALSE_NEGATIVE = 'w'
POINT_MARKERS = [
{
'change': 0,
import glob
import unittest
# import pickle
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.metrics import adjusted_rand_score
sys.path.append(os.path.abspath(os.path.join('..', '..'))) # Add path to root
import imsegm.utils.data_io as tl_data
import imsegm.utils.drawing as tl_visu
import imsegm.superpixels as seg_spx
import imsegm.region_growing as seg_rg
PATH_OVARY = os.path.join(tl_data.update_path('images', absolute=True),
'drosophila_ovary_slice')
PATH_IMAGE = os.path.join(PATH_OVARY, 'image')
PATH_SEGM = os.path.join(PATH_OVARY, 'segm')
PATH_ANNOT = os.path.join(PATH_OVARY, 'annot_eggs')
PATH_CENTRE = os.path.join(PATH_OVARY, 'center_levels')
PATH_OUTPUT = tl_data.update_path('output', absolute=True)
NAME_RG2SP_MODEL = 'RG2SP_multi-model_mixture.npz'
PATH_PKL_MODEL = os.path.join(PATH_OUTPUT, NAME_RG2SP_MODEL)
LABELS_FG_PROB = (0.05, 0.7, 0.9, 0.9)
DEFAULT_RG2SP_THRESHOLDS = seg_rg.RG2SP_THRESHOLDS
FIG_SIZE = 12.
def compute_prior_map(cdist, size=(500, 800), step=5):
prior_map = np.zeros(size)
# threshold if two segmentation overlap more, keep just one of them
SEGM_OVERLAP = 0.5
# paramters for SLIC segmentation
SLIC_SIZE = 40
SLIC_REGUL = 0.3
# Region Growing configuration
DEBUG_EXPORT = False
RG2SP_THRESHOLDS = { # thresholds for updating between iterations
'centre': 20,
'shift': 10,
'volume': 0.05,
'centre_init': 50
}
PATH_DATA = tl_data.update_path('data', absolute=True)
PATH_IMAGES = os.path.join(tl_data.update_path('data_images'),
'drosophila_ovary_slice')
# sample segmentation methods
LIST_SAMPLE_METHODS = ('ellipse_moments', 'ellipse_ransac_mmt',
'ellipse_ransac_crit', 'GC_pixels-large',
'GC_pixels-shape', 'GC_slic-large', 'GC_slic-shape',
'rg2sp_greedy-mixture', 'rg2sp_GC-mixture',
'watershed_morph')
# default segmentation configuration
SEGM_PARAMS = {
# ovary labels: background, funicular cells, nurse cells, cytoplasm
'tab-proba_ellipse': [0.01, 0.95, 0.95, 0.85],
'tab-proba_graphcut': [0.01, 0.6, 0.99, 0.75],
'tab-proba_RG2SP': [0.01, 0.6, 0.95, 0.75],
'path_single-model':
