def estim_model_classes_group(list_images, nb_classes, dict_features,
sp_size=30, sp_regul=0.2,
use_scaler=True, pca_coef=None, model_type='GMM',
nb_workers=NB_THREADS):
""" estimate a model from sequence of input images and return it as result
:param [ndarray] list_images:
:param int nb_classes: number of classes
:param int sp_size: initial size of a superpixel(meaning edge lenght)
:param float sp_regul: regularisation in range(0;1) where "0" gives elastic
and "1" nearly square slic
:param {str: [str]} dict_features: list of features to be extracted
:param float pca_coef: range (0, 1) or None
:param bool use_scaler: whether use a scaler
:param str model_type: model type
:param int nb_workers: number of jobs running in parallel
:return:
"""
list_slic, list_features = list(), list()
_wrapper_compute = partial(compute_color2d_superpixels_features,
sp_size=sp_size, sp_regul=sp_regul,
dict_features=dict_features)
iterate = WrapExecuteSequence(_wrapper_compute, list_images,
desc='compute SLIC & features',
nb_workers=nb_workers)
for slic, features in iterate:
list_slic.append(slic)
list_features.append(features)
features = np.concatenate(tuple(list_features), axis=0)
features = np.nan_to_num(features)
model = estim_class_model(features, nb_classes, model_type, pca_coef, use_scaler)
return model, list_features
def estim_model_classes_group(list_images,
nb_classes=4,
clr_space='rgb',
sp_size=30,
sp_regul=0.2,
dict_features=FTS_SET_SIMPLE,
pca_coef=None,
proba_type='GMM',
nb_jobs=NB_THREADS):
""" estimate a model from sequence of input images and return it as result
:param [ndarray] list_images:
:param int nb_classes: number of clasees
:param str clr_space: chose the color space
:param int sp_size: initial size of a superpixel(meaning edge lenght)
:param float sp_regul: regularisation in range(0;1) where "0" gives elastic
and "1" nearly square slic
:param {str: [str]} dict_features: list of features to be extracted
:param float pca_coef: range (0, 1) or None
:param str proba_type: model type
:param int nb_jobs: number of jobs running in parallel
:return:
"""
list_slic, list_features = list(), list()
wrapper_compute = partial(compute_color2d_superpixels_features,
sp_size=sp_size,
sp_regul=sp_regul,
dict_features=dict_features,
clr_space=clr_space,
fts_norm=False)
iterate = tl_expt.WrapExecuteSequence(wrapper_compute,
list_images,
nb_jobs=nb_jobs)
for slic, features in iterate:
list_slic.append(slic)
list_features.append(features)
# for img in list_images:
# slic, features = compute_color2d_superpixels_features(img, sp_size,
# sp_regul, dict_features, clr_space, fts_norm=False)
# list_slic.append(slic)
# list_features.append(features)
features = np.concatenate(tuple(list_features), axis=0)
features = np.nan_to_num(features)
# scaling
scaler = preprocessing.StandardScaler()
scaler.fit(features)
features = scaler.transform(features)
pca = None
if pca_coef is not None:
pca = decomposition.PCA(pca_coef)
features = pca.fit_transform(features)
model = seg_gc.estim_class_model(features, nb_classes, proba_type)
return scaler, pca, model
def pipe_gray3d_slic_features_model_graphcut(
image,
nb_classes,
dict_features,
spacing=(12, 1, 1),
sp_size=15,
sp_regul=0.2,
gc_regul=0.1,
):
""" complete pipe-line for segmentation using superpixels, extracting features
and graphCut segmentation
:param ndarray image: input RGB image
:param int sp_size: initial size of a superpixel(meaning edge lenght)
:param float sp_regul: regularisation in range(0;1) where "0" gives elastic
and "1" nearly square segments
:param int nb_classes: number of classes to be segmented(indexing from 0)
:param tuple(int,int,int) spacing:
:param float gc_regul: regularisation for GC
:return list(list(int)): segmentation matrix maping each pixel into a class
>>> np.random.seed(0)
>>> image = np.random.random((5, 125, 150)) / 2.
>>> image[:, :, :75] += 0.5
>>> segm = pipe_gray3d_slic_features_model_graphcut(image, 2, {'color': ['mean']})
>>> segm.shape
(5, 125, 150)
"""
logging.info('PIPELINE Superpixels-Features-GraphCut')
slic = segment_slic_img3d_gray(image,
sp_size=sp_size,
relative_compact=sp_regul,
space=spacing)
# plt.imshow(segments)
logging.info('extract segments/superpixels features.')
# f = features.computeColourMean(image, segments)
features, _ = compute_selected_features_gray3d(image, slic, dict_features)
# merge features together
logging.debug('list of features RAW: %r', features.shape)
features[np.isnan(features)] = 0
logging.info('norm all features.')
features, _ = norm_features(features)
logging.debug('list of features NORM: %r', features.shape)
model = estim_class_model(features, nb_classes)
proba = model.predict_proba(features)
logging.debug('list of probabilities: %r', proba.shape)
# resultGraph = graphCut.segment_graph_cut_int_vals(segments, prob, gcReg)
graph_labels = segment_graph_cut_general(slic, proba, image, features,
gc_regul)
return graph_labels[slic]
def pipe_color2d_slic_features_model_graphcut(image,
nb_classes,
dict_features,
sp_size=30,
sp_regul=0.2,
pca_coef=None,
use_scaler=True,
estim_model='GMM',
gc_regul=1.,
gc_edge_type='model',
debug_visual=None):
""" complete pipe-line for segmentation using superpixels, extracting features
and graphCut segmentation
:param ndarray image: input RGB image
:param int nb_classes: number of classes to be segmented(indexing from 0)
:param int sp_size: initial size of a superpixel(meaning edge length)
:param float sp_regul: regularisation in range(0,1) where 0 gives elastic
and 1 nearly square slic
:param dict dict_features: {clr: list(str)}
:param float pca_coef: range (0, 1) or None
:param str estim_model: estimating model
:param float gc_regul: GC regularisation
:param str gc_edge_type: graphCut edge type
:param bool use_scaler: using scaler block in pipeline
:param debug_visual: dict
:return list(list(int)): segmentation matrix maping each pixel into a class
>>> np.random.seed(0)
>>> image = np.random.random((125, 150, 3)) / 2.
>>> image[:, :75] += 0.5
>>> segm, seg_soft = pipe_color2d_slic_features_model_graphcut(
... image, 2, {'color': ['mean']})
>>> segm.shape
(125, 150)
>>> seg_soft.shape
(125, 150, 2)
"""
logging.info('PIPELINE Superpixels-Features-GMM-GraphCut')
slic, features = compute_color2d_superpixels_features(image,
dict_features,
sp_size=sp_size,
sp_regul=sp_regul)
if debug_visual is not None:
if image.ndim == 2: # duplicate channels to be like RGB
image = np.rollaxis(np.tile(image, (3, 1, 1)), 0, 3)
debug_visual['image'] = image
debug_visual['slic'] = slic
debug_visual['slic_mean'] = sk_color.label2rgb(slic, image, kind='avg')
model = estim_class_model(features, nb_classes, estim_model, pca_coef,
use_scaler)
proba = model.predict_proba(features)
logging.debug('list of probabilities: %r', proba.shape)
# gmm = mixture.GaussianMixture(n_components=nb_classes,
# covariance_type='full', max_iter=1)
# gmm.fit(features, np.argmax(proba, axis=1))
# proba = gmm.predict_proba(features)
segm_soft = proba[slic]
graph_labels = segment_graph_cut_general(slic,
proba,
image,
features,
gc_regul,
gc_edge_type,
debug_visual=debug_visual)
segm = graph_labels[slic]
return segm, segm_soft
def pipe_color2d_slic_features_gmm_graphcut(image,
nb_classes=3,
clr_space='rgb',
sp_size=30,
sp_regul=0.2,
gc_regul=1.,
dict_features=FTS_SET_SIMPLE,
proba_type='GMM',
gc_edge_type='model_lT',
pca_coef=None,
dict_debug_imgs=None):
""" complete pipe-line for segmentation using superpixels, extracting features
and graphCut segmentation
:param float gc_regul: GC regularisation
:param image: input RGB image
:param int sp_size: initial size of a superpixel(meaning edge lenght)
:param float sp_regul: regularisation in range(0;1) where "0" gives elastic
and "1" nearly square slic
:param int nb_classes: number of classes to be segmented(indexing from 0)
:param dict_features: {clr: [str], ...}
:param str clr_space: use color space
:param float gc_regul: GC regularisation
:param str gc_edge_type: graphCut edge type
:param float pca_coef: range (0, 1) or None
:param dict_debug_imgs: {str: ...}
:return [[int]]: segmentation matrix maping each pixel into a class
>>> np.random.seed(0)
>>> image = np.random.random((125, 150, 3)) / 2.
>>> image[:, :75] += 0.5
>>> segm = pipe_color2d_slic_features_gmm_graphcut(image, nb_classes=2)
>>> segm.shape
(125, 150)
"""
logging.info('PIPELINE Superpixels-Features-GMM-GraphCut')
slic, features = compute_color2d_superpixels_features(
image, clr_space, sp_size, sp_regul, dict_features)
if dict_debug_imgs is not None:
if image.ndim == 2: # duplicate channels to be like RGB
image = np.rollaxis(np.tile(image, (3, 1, 1)), 0, 3)
dict_debug_imgs['image'] = image
dict_debug_imgs['slic'] = slic
dict_debug_imgs['slic_mean'] = sk_color.label2rgb(slic,
image,
kind='avg')
if pca_coef is not None:
pca = decomposition.PCA(pca_coef)
features = pca.fit_transform(features)
model = seg_gc.estim_class_model(features, nb_classes, proba_type)
proba = model.predict_proba(features)
logging.debug('list of probabilities: %s', repr(proba.shape))
gmm = mixture.GaussianMixture(n_components=nb_classes,
covariance_type='full',
max_iter=1)
gmm.fit(features, np.argmax(proba, axis=1))
proba = gmm.predict_proba(features)
graph_labels = seg_gc.segment_graph_cut_general(
slic,
proba,
image,
features,
gc_regul,
gc_edge_type,
dict_debug_imgs=dict_debug_imgs)
segm = graph_labels[slic]
return segm
