def sequence_registration(list_images, method=None, **kwds):
"""
Sequence registration plugin. Available methods are :
* sequence_rigid_registration
* sequence_affine_registration
Parameters
----------
:param list list_images: list of *SpatialImage*
:param str method: used method (example: 'sequence_registration_rigid')
Returns
----------
:return: list_compo_trsf -- list of *BalTransformation* transformation
:return: list_res_img -- list of *SpatialImage*
Example
----------
>>> from timagetk.util import data_path
>>> from timagetk.components import imread
>>> from timagetk.plugins import sequence_registration
>>> times = [0, 1, 2]
>>> list_images = [imread(data_path('time_' + str(time) + '.inr'))
for time in times]
>>> list_compo_trsf, list_res_img = sequence_registration(list_images,
method='sequence_rigid_registration')
>>> list_compo_trsf, list_res_img = sequence_registration(list_images,
method='sequence_affine_registration')
"""
poss_methods = ['sequence_rigid_registration', 'sequence_affine_registration']
conds_init = isinstance(list_images, list) and len(list_images)>=3
conds_list_img = [0 if isinstance(sp_img, SpatialImage) else 1
for sp_img in list_images]
#--- end check
if conds_init and 1 not in conds_list_img:
if method is None:
list_compo_trsf, list_res_img = sequence_registration_rigid(list_images)
return list_compo_trsf, list_res_img
elif method is not None:
if method in poss_methods:
try:
from openalea.core.service.plugin import plugin_function
func = plugin_function('openalea.image', method)
if func is not None:
return func(list_images, **kwds)
except:
if method=='sequence_rigid_registration':
list_compo_trsf, list_res_img = sequence_registration_rigid(list_images)
elif method=='sequence_affine_registration':
list_compo_trsf, list_res_img = sequence_registration_affine(list_images)
return list_compo_trsf, list_res_img
else:
print('Available methods :'), poss_methods
raise NotImplementedError(method)
else:
raise TypeError('list_images must be a list of SpatialImage')
return
def labels_post_processing(input_image, method=None, **kwds):
"""
Labels post-processing algorithms. Available methods are :
* labels_erosion
* labels_dilation
* labels_opening
* labels_closing
Parameters
----------
:param *SpatialImage* input_image: input *SpatialImage*
:param str method: used method (example: 'labels_erosion')
Returns
----------
:return: ``SpatialImage`` instance -- image and metadata
Example
----------
>>> from timagetk.util import data, data_path
>>> from timagetk.util import labels_post_processing
>>> image_path = data_path('segmentation_seeded_watershed.inr')
>>> segmented_image = data(image_path)
>>> ero_image = labels_post_processing(segmented_image, radius=2, iterations=1,
method='labels_erosion')
>>> open_image = labels_post_processing(segmented_image, method='labels_opening')
"""
poss_methods = ['labels_erosion', 'labels_dilation', 'labels_opening', 'labels_closing']
conds = isinstance(input_image, SpatialImage)
if conds:
if method is None:
return labels_erosion(input_image)
elif method is not None:
if method in poss_methods:
try:
from openalea.core.service.plugin import plugin_function
func = plugin_function('openalea.image', method)
if func is not None:
return func(input_image, **kwds)
except:
radius_val = kwds.get('radius', None)
it_val = kwds.get('iterations', None)
if method=='labels_erosion':
return labels_erosion(input_image, radius=radius_val, iterations=it_val)
elif method=='labels_dilation':
return labels_dilation(input_image, radius=radius_val, iterations=it_val)
elif method=='labels_opening':
return labels_opening(input_image, radius=radius_val, iterations=it_val)
elif method=='labels_closing':
return labels_closing(input_image, radius=radius_val, iterations=it_val)
else:
print('Available methods :'), poss_methods
raise NotImplementedError(method)
else:
raise TypeError('Input image must be a SpatialImage')
return
def averaging(list_images, method=None, **kwds):
"""
Averaging plugin. Available methods are :
* mean_averaging
* robust_mean_averaging
* median_averaging
* minimum_averaging
* maximum_averaging
Parameters
----------
:param list list_images: list of *SpatialImage*
:param str method: used method (example: 'mean_averaging')
Returns
----------
:return: ``SpatialImage`` instance -- image and metadata
Example
----------
>>> from timagetk.util import data, data_path
>>> from timagetk.plugins import averaging
>>> image_path = data_path('time_0_cut.inr')
>>> input_image = data(image_path)
>>> list_images = [input_image, input_image, input_image]
>>> rob_mean_image = averaging(list_images, method='robust_mean_averaging')
>>> mean_image = averaging(list_images, method='mean_averaging')
"""
poss_methods = [
'mean_averaging', 'robust_mean_averaging', 'median_averaging',
'minimum_averaging', 'maximum_averaging'
]
if method is None:
return mean_averaging(list_images)
elif method is not None:
if method in poss_methods:
try:
from openalea.core.service.plugin import plugin_function
func = plugin_function('openalea.image', method)
if func is not None:
return func(list_images, **kwds)
except ImportError:
if method == 'mean_averaging':
return mean_averaging(list_images, **kwds)
elif method == 'robust_mean_averaging':
return robust_mean_averaging(list_images, **kwds)
elif method == 'median_averaging':
return median_averaging(list_images, **kwds)
elif method == 'minimum_averaging':
return min_averaging(list_images, **kwds)
elif method == 'maximum_averaging':
return max_averaging(list_images, **kwds)
else:
print('Available methods :'), poss_methods
raise NotImplementedError(method)
def averaging(list_images, method=None, **kwds):
"""
Averaging plugin. Available methods are :
* mean_averaging
* robust_mean_averaging
* median_averaging
* minimum_averaging
* maximum_averaging
Parameters
----------
:param list list_images: list of *SpatialImage*
:param str method: used method (example: 'mean_averaging')
Returns
----------
:return: ``SpatialImage`` instance -- image and metadata
Example
----------
>>> from timagetk.util import data, data_path
>>> from timagetk.plugins import averaging
>>> image_path = data_path('time_0_cut.inr')
>>> input_image = data(image_path)
>>> list_images = [input_image, input_image, input_image]
>>> rob_mean_image = averaging(list_images, method='robust_mean_averaging')
>>> mean_image = averaging(list_images, method='mean_averaging')
"""
poss_methods = ['mean_averaging', 'robust_mean_averaging', 'median_averaging',
'minimum_averaging', 'maximum_averaging']
if method is None:
return mean_averaging(list_images)
elif method is not None:
if method in poss_methods:
try:
from openalea.core.service.plugin import plugin_function
func = plugin_function('openalea.image', method)
if func is not None:
return func(list_images, **kwds)
except ImportError:
if method=='mean_averaging':
return mean_averaging(list_images, **kwds)
elif method=='robust_mean_averaging':
return robust_mean_averaging(list_images, **kwds)
elif method=='median_averaging':
return median_averaging(list_images, **kwds)
elif method=='minimum_averaging':
return min_averaging(list_images, **kwds)
elif method=='maximum_averaging':
return max_averaging(list_images, **kwds)
else:
print('Available methods :'), poss_methods
raise NotImplementedError(method)
def segmentation(input_image, seeds_image, method=None, **kwds):
"""
Segmentation plugin. Available methods are :
* seeded_watershed
Parameters
----------
:param *SpatialImage* input_image: input *SpatialImage*
:param *SpatialImage* seeds_image: seeds *SpatialImage*
:param str method: used method (example: 'seeded_watershed')
Returns
----------
:return: ``SpatialImage`` instance -- image and metadata
Example
----------
>>> from timagetk.util import data, data_path
>>> from timagetk.plugins import linear_filtering, h_transform, region_labeling, segmentation
>>> image_path = data_path('segmentation_src.inr')
>>> input_image = data(image_path)
>>> smooth_image = linear_filtering(input_image, std_dev=2.0, method='gaussian_smoothing')
>>> regext_image = h_transform(smooth_image, h=5, method='h_transform_min')
>>> seeds_image = region_labeling(regext_image, low_threshold=1, high_threshold=3,
method='connected_components')
>>> segmented_image = segmentation(smooth_image, seeds_image, control='first',
method='seeded_watershed')
"""
poss_methods = ['seeded_watershed']
conds = isinstance(input_image, SpatialImage) and isinstance(
seeds_image, SpatialImage)
if conds:
if method is None:
return seeded_watershed(input_image, seeds_image)
elif method is not None:
if method in poss_methods:
try:
from openalea.core.service.plugin import plugin_function
func = plugin_function('openalea.image', method)
if func is not None:
return func(input_image, seeds_image, **kwds)
except:
control_val = kwds.get('control', None)
return seeded_watershed(input_image,
seeds_image,
control=control_val)
else:
print('Available methods :'), poss_methods
raise NotImplementedError(method)
else:
raise TypeError('Input image and seeds image must be a SpatialImage')
return
def h_transform(input_image, method=None, **kwds):
"""
h_transform plugin. Available methods are :
* h_transform_min
* h_transform_max
Parameters
----------
:param *SpatialImage* input_image: input *SpatialImage*
:param str method: used method (example: 'min')
:param int h: optional, h value. Default: h=1
Returns
----------
:return: ``SpatialImage`` instance -- image and metadata
Example
----------
>>> from timagetk.util import data, data_path
>>> from timagetk.plugins import h_transform
>>> img_path = data_path('filtering_src.inr')
>>> input_image = data(img_path)
>>> reg_max_image = h_transform(input_image)
>>> reg_max_image = h_transform(input_image, h=3, method='h_transform_max')
>>> reg_min_image = h_transform(input_image, h=3, method='h_transform_min')
"""
poss_methods = ['h_transform_min', 'h_transform_max']
conds = isinstance(input_image, SpatialImage)
if conds:
if method is None:
return h_transform_min(input_image)
elif method is not None:
if method in poss_methods:
try:
from openalea.core.service.plugin import plugin_function
func = plugin_function('openalea.image', method)
if func is not None:
return func(input_image, **kwds)
except:
h_val = kwds.get('h', None)
if method=='h_transform_min':
return h_transform_min(input_image, h=h_val)
elif method=='h_transform_max':
return h_transform_max(input_image, h=h_val)
else:
print('Available methods :'), poss_methods
raise NotImplementedError(method)
else:
raise TypeError('Input image must be a SpatialImage')
return
def h_transform(input_image, method=None, **kwds):
"""
h_transform plugin. Available methods are :
* h_transform_min
* h_transform_max
Parameters
----------
:param *SpatialImage* input_image: input *SpatialImage*
:param str method: used method (example: 'min')
:param int h: optional, h value. Default: h=1
Returns
----------
:return: ``SpatialImage`` instance -- image and metadata
Example
----------
>>> from timagetk.util import data, data_path
>>> from timagetk.plugins import h_transform
>>> img_path = data_path('filtering_src.inr')
>>> input_image = data(img_path)
>>> reg_max_image = h_transform(input_image)
>>> reg_max_image = h_transform(input_image, h=3, method='h_transform_max')
>>> reg_min_image = h_transform(input_image, h=3, method='h_transform_min')
"""
poss_methods = ['h_transform_min', 'h_transform_max']
conds = isinstance(input_image, SpatialImage)
if conds:
if method is None:
return h_transform_min(input_image)
elif method is not None:
if method in poss_methods:
try:
from openalea.core.service.plugin import plugin_function
func = plugin_function('openalea.image', method)
if func is not None:
return func(input_image, **kwds)
except:
h_val = kwds.get('h', None)
if method == 'h_transform_min':
return h_transform_min(input_image, h=h_val)
elif method == 'h_transform_max':
return h_transform_max(input_image, h=h_val)
else:
print('Available methods :'), poss_methods
raise NotImplementedError(method)
else:
raise TypeError('Input image must be a SpatialImage')
return
def region_labeling(input_image, method=None, **kwds):
"""
Region labeling plugin. Available methods are :
* connected_components
Parameters
----------
:param *SpatialImage* input_image: input *SpatialImage*
:param str method: used method (example: 'connected_components')
Returns
----------
:return: ``SpatialImage`` instance -- image and metadata
Example
----------
>>> from timagetk.util import data, data_path
>>> from timagetk.plugins import h_transform, region_labeling
>>> image_path = data_path('time_0_cut.inr')
>>> input_image = data(image_path)
>>> reg_min_image = h_transform(input_image, h=3, method='h_transform_min')
>>> reg_lab_image = region_labeling(reg_min_image, low_threshold=1,
high_threshold=3, method='connected_components')
"""
poss_methods = ['connected_components']
conds = isinstance(input_image, SpatialImage)
if conds:
if method is None:
return connected_components(input_image)
elif method is not None:
if method in poss_methods:
try:
from openalea.core.service.plugin import plugin_function
func = plugin_function('openalea.image', method)
if func is not None:
return func(input_image, **kwds)
except:
if method == 'connected_components':
low_threshold_val = kwds.get('low_threshold', None)
high_threshold_val = kwds.get('high_threshold', None)
return connected_components(
input_image,
low_threshold=low_threshold_val,
high_threshold=high_threshold_val)
else:
print('Available methods :'), poss_methods
raise NotImplementedError(method)
else:
raise TypeError('Input image must be a SpatialImage')
return
def segmentation(input_image, seeds_image, method=None, **kwds):
"""
Segmentation plugin. Available methods are :
* seeded_watershed
Parameters
----------
:param *SpatialImage* input_image: input *SpatialImage*
:param *SpatialImage* seeds_image: seeds *SpatialImage*
:param str method: used method (example: 'seeded_watershed')
Returns
----------
:return: ``SpatialImage`` instance -- image and metadata
Example
----------
>>> from timagetk.util import data, data_path
>>> from timagetk.plugins import linear_filtering, h_transform, region_labeling, segmentation
>>> image_path = data_path('segmentation_src.inr')
>>> input_image = data(image_path)
>>> smooth_image = linear_filtering(input_image, std_dev=2.0, method='gaussian_smoothing')
>>> regext_image = h_transform(smooth_image, h=5, method='h_transform_min')
>>> seeds_image = region_labeling(regext_image, low_threshold=1, high_threshold=3,
method='connected_components')
>>> segmented_image = segmentation(smooth_image, seeds_image, control='first',
method='seeded_watershed')
"""
poss_methods = ['seeded_watershed']
conds = isinstance(input_image, SpatialImage) and isinstance(seeds_image, SpatialImage)
if conds:
if method is None:
return seeded_watershed(input_image, seeds_image)
elif method is not None:
if method in poss_methods:
try:
from openalea.core.service.plugin import plugin_function
func = plugin_function('openalea.image', method)
if func is not None:
return func(input_image, seeds_image, **kwds)
except:
control_val = kwds.get('control', None)
return seeded_watershed(input_image, seeds_image, control=control_val)
else:
print('Available methods :'), poss_methods
raise NotImplementedError(method)
else:
raise TypeError('Input image and seeds image must be a SpatialImage')
return
def region_segmentation(original, method, **kwds):
"""
:param original: original image
:type original: :class:`~openalea.image.spatial_image.SpatialImage`
:param method: method identifier you want to use (ex: "extension_based")
:type method: :obj:`str`
"""
func = plugin_function('openalea.image', method)
if func is not None:
return func(original, **kwds)
else:
raise NotImplementedError(method)
def region_labeling(input_image, method=None, **kwds):
"""
Region labeling plugin. Available methods are :
* connected_components
Parameters
----------
:param *SpatialImage* input_image: input *SpatialImage*
:param str method: used method (example: 'connected_components')
Returns
----------
:return: ``SpatialImage`` instance -- image and metadata
Example
----------
>>> from timagetk.util import data, data_path
>>> from timagetk.plugins import h_transform, region_labeling
>>> image_path = data_path('time_0_cut.inr')
>>> input_image = data(image_path)
>>> reg_min_image = h_transform(input_image, h=3, method='h_transform_min')
>>> reg_lab_image = region_labeling(reg_min_image, low_threshold=1,
high_threshold=3, method='connected_components')
"""
poss_methods = ['connected_components']
conds = isinstance(input_image, SpatialImage)
if conds:
if method is None:
return connected_components(input_image)
elif method is not None:
if method in poss_methods:
try:
from openalea.core.service.plugin import plugin_function
func = plugin_function('openalea.image', method)
if func is not None:
return func(input_image, **kwds)
except:
if method=='connected_components':
low_threshold_val = kwds.get('low_threshold', None)
high_threshold_val = kwds.get('high_threshold', None)
return connected_components(input_image, low_threshold=low_threshold_val,
high_threshold=high_threshold_val)
else:
print('Available methods :'), poss_methods
raise NotImplementedError(method)
else:
raise TypeError('Input image must be a SpatialImage')
return
def region_selection(segmented, labels, method, **kwds):
"""
:param segmented: segmented image
:type segmented: :class:`~openalea.image.spatial_image.SpatialImage`
:param labels: label image
:type labels: :class:`~openalea.image.spatial_image.SpatialImage`
:param method: method identifier you want to use (ex: "remove_small_cells")
:type method: :obj:`str`
"""
func = plugin_function('openalea.image', method)
if func is not None:
return func(segmented, labels, **kwds)
else:
raise NotImplementedError(method)
def image_filtering(original, method=None, **kwds):
"""
:param original: original image
:type original: :class:`~openalea.image.spatial_image.SpatialImage`
:param method: method identifier you want to use (ex: "gaussian_smoothing")
:type method: :obj:`str`
"""
if method is None:
return original
func = plugin_function('openalea.image', method)
if func is not None:
return func(original, **kwds)
else:
raise NotImplementedError(method)
def sequence_registration(list_images, method=None, **kwds):
"""
Sequence registration plugin. Available methods are :
* sequence_rigid_registration
* sequence_affine_registration
Parameters
----------
:param list list_images: list of *SpatialImage*
:param str method: used method (example: 'sequence_registration_rigid')
Returns
----------
:return: list_compo_trsf -- list of *BalTransformation* transformation
:return: list_res_img -- list of *SpatialImage*
Example
----------
>>> from timagetk.util import data_path
>>> from timagetk.components import imread
>>> from timagetk.plugins import sequence_registration
>>> times = [0, 1, 2]
>>> list_images = [imread(data_path('time_' + str(time) + '.inr'))
for time in times]
>>> list_compo_trsf, list_res_img = sequence_registration(list_images,
method='sequence_rigid_registration')
>>> list_compo_trsf, list_res_img = sequence_registration(list_images,
method='sequence_affine_registration')
"""
poss_methods = [
'sequence_rigid_registration', 'sequence_affine_registration'
]
conds_init = isinstance(list_images, list) and len(list_images) >= 3
conds_list_img = [
0 if isinstance(sp_img, SpatialImage) else 1 for sp_img in list_images
]
#--- end check
if conds_init and 1 not in conds_list_img:
if method is None:
list_compo_trsf, list_res_img = sequence_registration_rigid(
list_images)
return list_compo_trsf, list_res_img
elif method is not None:
if method in poss_methods:
try:
from openalea.core.service.plugin import plugin_function
func = plugin_function('openalea.image', method)
if func is not None:
return func(list_images, **kwds)
except:
if method == 'sequence_rigid_registration':
list_compo_trsf, list_res_img = sequence_registration_rigid(
list_images)
elif method == 'sequence_affine_registration':
list_compo_trsf, list_res_img = sequence_registration_affine(
list_images)
return list_compo_trsf, list_res_img
else:
print('Available methods :'), poss_methods
raise NotImplementedError(method)
else:
raise TypeError('list_images must be a list of SpatialImage')
return
def labels_post_processing(input_image, method=None, **kwds):
"""
Labels post-processing algorithms. Available methods are :
* labels_erosion
* labels_dilation
* labels_opening
* labels_closing
Parameters
----------
:param *SpatialImage* input_image: input *SpatialImage*
:param str method: used method (example: 'labels_erosion')
Returns
----------
:return: ``SpatialImage`` instance -- image and metadata
Example
----------
>>> from timagetk.util import data, data_path
>>> from timagetk.util import labels_post_processing
>>> image_path = data_path('segmentation_seeded_watershed.inr')
>>> segmented_image = data(image_path)
>>> ero_image = labels_post_processing(segmented_image, radius=2, iterations=1,
method='labels_erosion')
>>> open_image = labels_post_processing(segmented_image, method='labels_opening')
"""
poss_methods = [
'labels_erosion', 'labels_dilation', 'labels_opening', 'labels_closing'
]
conds = isinstance(input_image, SpatialImage)
if conds:
if method is None:
return labels_erosion(input_image)
elif method is not None:
if method in poss_methods:
try:
from openalea.core.service.plugin import plugin_function
func = plugin_function('openalea.image', method)
if func is not None:
return func(input_image, **kwds)
except:
radius_val = kwds.get('radius', None)
it_val = kwds.get('iterations', None)
if method == 'labels_erosion':
return labels_erosion(input_image,
radius=radius_val,
iterations=it_val)
elif method == 'labels_dilation':
return labels_dilation(input_image,
radius=radius_val,
iterations=it_val)
elif method == 'labels_opening':
return labels_opening(input_image,
radius=radius_val,
iterations=it_val)
elif method == 'labels_closing':
return labels_closing(input_image,
radius=radius_val,
iterations=it_val)
else:
print('Available methods :'), poss_methods
raise NotImplementedError(method)
else:
raise TypeError('Input image must be a SpatialImage')
return
def morphology(input_image, method=None, **kwds):
"""
Grayscale morphology plugin. Available methods are :
* erosion
* dilation
* opening
* closing
* morpho_gradient
* contrast
* hat_transform
* inverse_hat_transform
* oc_alternate_sequential_filter
* co_alternate_sequential_filter
* coc_alternate_sequential_filter
* oco_alternate_sequential_filter
Parameters
----------
:param *SpatialImage* input_image: input *SpatialImage*
:param str method: used method (example: 'erosion')
Returns
----------
:return: ``SpatialImage`` instance -- image and metadata
Example
----------
>>> from timagetk.util import data, data_path
>>> from timagetk.plugins import morphology
>>> image_path = data_path('time_0_cut.inr')
>>> input_image = data(image_path)
>>> dilation_image = morphology(input_image, radius=2, iterations=2, method='dilation')
>>> oc_asf_image = morphology(input_image, max_radius=3, method='oc_alternate_sequential_filter')
"""
poss_methods = ['erosion', 'dilation', 'opening', 'closing', 'morpho_gradient', 'contrast',
'hat_transform', 'inverse_hat_transform', 'oc_alternate_sequential_filter',
'co_alternate_sequential_filter', 'coc_alternate_sequential_filter',
'oco_alternate_sequential_filter']
conds = isinstance(input_image, SpatialImage)
if conds:
if method is None:
return morphology_erosion(input_image)
elif method is not None:
if method in poss_methods:
try:
from openalea.core.service.plugin import plugin_function
func = plugin_function('openalea.image', method)
if func is not None:
return func(input_image, **kwds)
except:
radius_val = kwds.get('radius', None)
it_val = kwds.get('iterations', None)
max_radius_val = kwds.get('max_radius', None)
if method=='erosion':
return morphology_erosion(input_image, radius=radius_val, iterations=it_val)
elif method=='dilation':
return morphology_dilation(input_image, radius=radius_val, iterations=it_val)
elif method=='opening':
return morphology_opening(input_image, radius=radius_val, iterations=it_val)
elif method=='closing':
return morphology_closing(input_image, radius=radius_val, iterations=it_val)
elif method=='morpho_gradient':
return morphology_gradient(input_image, radius=radius_val, iterations=it_val)
elif method=='contrast':
return morphology_contrast(input_image, radius=radius_val, iterations=it_val)
elif method=='hat_transform':
return morphology_hat_transform(input_image, radius=radius_val, iterations=it_val)
elif method=='inverse_hat_transform':
return morphology_inverse_hat_transform(input_image, radius=radius_val, iterations=it_val)
elif method=='oc_alternate_sequential_filter':
return morphology_oc_alternate_sequential_filter(input_image, max_radius=max_radius_val)
elif method=='co_alternate_sequential_filter':
return morphology_co_alternate_sequential_filter(input_image, max_radius=max_radius_val)
elif method=='coc_alternate_sequential_filter':
return morphology_coc_alternate_sequential_filter(input_image, max_radius=max_radius_val)
elif method=='oco_alternate_sequential_filter':
return morphology_oco_alternate_sequential_filter(input_image, max_radius=max_radius_val)
else:
print('Available methods :'), poss_methods
raise NotImplementedError(method)
else:
raise TypeError('Input image must be a SpatialImage')
return
def registration(floating_img, reference_img, method=None, **kwds):
"""
Registration plugin. Available methods are :
* rigid_registration
* affine_registration
* deformable_registration
Parameters
----------
:param *SpatialImage* floating_img: floating *SpatialImage*
:param *SpatialImage* reference_img: reference *SpatialImage*
:param str method: used method (example: 'rigid_registration')
Returns
----------
:return: ``BalTransformation`` instance -- trsf_out, *BalTransformation* transformation
:return: ``SpatialImage`` instance -- res_image, *SpatialImage* image and metadata
Example
----------
>>> from timagetk.util import data, data_path
>>> from timagetk.plugins import registration
>>> image_path = data_path('time_0_cut.inr')
>>> floating_image = data(image_path)
>>> image_path = data_path('time_1_cut.inr')
>>> reference_image = data(image_path)
>>> trsf_rig, res_rig = registration(floating_image, reference_image, method='rigid_registration')
>>> trsf_aff, res_aff = registration(floating_image, reference_image, method='affine_registration')
>>> trsf_def, res_def = registration(floating_image, reference_image, method='deformable_registration')
"""
poss_methods = ['rigid_registration', 'affine_registration', 'deformable_registration']
conds = isinstance(floating_img, SpatialImage) and isinstance(reference_img, SpatialImage)
if conds:
if method is None:
return rigid_registration(floating_img, reference_img)
elif method is not None:
if method in poss_methods:
try:
from openalea.core.service.plugin import plugin_function
func = plugin_function('openalea.image', method)
if func is not None:
return func(floating_img, reference_img, **kwds)
except:
if method=='rigid_registration':
trsf_out, res_image = rigid_registration(floating_img, reference_img)
return trsf_out, res_image
elif method=='affine_registration':
trsf_out, res_image = affine_registration(floating_img, reference_img)
return trsf_out, res_image
elif method=='deformable_registration':
trsf_out, res_image = deformable_registration(floating_img, reference_img)
return trsf_out, res_image
else:
print('Available methods :'), poss_methods
raise NotImplementedError(method)
else:
raise TypeError('Floating image and Refernece image must be a SpatialImage')
return
def linear_filtering(input_image, method=None, **kwds):
"""
Linear filtering plugin. Available methods are :
* gaussian_smoothing
* gradient
* gradient_modulus
* hessian
* laplacian
* gradient_hessian
* gradient_laplacian
* zero_crossings_hessian
* zero_crossings_laplacian
Parameters
----------
:param *SpatialImage* input_image: input *SpatialImage*
:param str method: used method (example: 'gaussian_smoothing')
Returns
----------
:return: ``SpatialImage`` instance -- image and metadata
Example
----------
>>> from timagetk.util import data, data_path
>>> from timagetk.plugins import linear_filtering
>>> image_path = data_path('time_0_cut.inr')
>>> input_image = data(image_path)
>>> gauss_image = linear_filtering(input_image, std_dev=2.0, method='gaussian_smoothing')
>>> grad_mod_image = linear_filtering(input_image, method='gradient_modulus')
>>> lap_image = linear_filtering(input_image, method='laplacian')
"""
poss_methods = [
'gaussian_smoothing', 'gradient', 'gradient_modulus', 'hessian',
'laplacian', 'gradient_hessian', 'gradient_laplacian',
'zero_crossings_hessian', 'zero_crossings_laplacian'
]
conds = isinstance(input_image, SpatialImage)
if conds:
if method is None:
return linear_filtering_gaussian_smoothing(input_image)
elif method is not None:
if method in poss_methods:
try:
from openalea.core.service.plugin import plugin_function
func = plugin_function('openalea.image', method)
if func is not None:
return func(input_image, **kwds)
except:
if method == 'gaussian_smoothing':
std_dev_val = kwds.get('std_dev', None)
return linear_filtering_gaussian_smoothing(
input_image, std_dev=std_dev_val)
elif method == 'gradient':
return linear_filtering_gradient(input_image)
elif method == 'gradient_modulus':
return linear_filtering_gradient_modulus(input_image)
elif method == 'hessian':
return linear_filtering_hessian(input_image)
elif method == 'laplacian':
return linear_filtering_laplacian(input_image)
elif method == 'gradient_hessian':
return linear_filtering_gradient_hessian(input_image)
elif method == 'gradient_laplacian':
return linear_filtering_gradient_laplacian(input_image)
elif method == 'zero_crossings_hessian':
return linear_filtering_zero_crossings_hessian(
input_image)
elif method == 'zero_crossings_laplacian':
return linear_filtering_zero_crossings_laplacian(
input_image)
else:
print('Available methods :'), poss_methods
raise NotImplementedError(method)
else:
raise TypeError('Input image must be a SpatialImage')
return
def registration(floating_img, reference_img, method=None, **kwds):
"""
Registration plugin. Available methods are :
* rigid_registration
* affine_registration
* deformable_registration
Parameters
----------
:param *SpatialImage* floating_img: floating *SpatialImage*
:param *SpatialImage* reference_img: reference *SpatialImage*
:param str method: used method (example: 'rigid_registration')
Returns
----------
:return: ``BalTransformation`` instance -- trsf_out, *BalTransformation* transformation
:return: ``SpatialImage`` instance -- res_image, *SpatialImage* image and metadata
Example
----------
>>> from timagetk.util import data, data_path
>>> from timagetk.plugins import registration
>>> image_path = data_path('time_0_cut.inr')
>>> floating_image = data(image_path)
>>> image_path = data_path('time_1_cut.inr')
>>> reference_image = data(image_path)
>>> trsf_rig, res_rig = registration(floating_image, reference_image, method='rigid_registration')
>>> trsf_aff, res_aff = registration(floating_image, reference_image, method='affine_registration')
>>> trsf_def, res_def = registration(floating_image, reference_image, method='deformable_registration')
"""
poss_methods = [
'rigid_registration', 'affine_registration', 'deformable_registration'
]
conds = isinstance(floating_img, SpatialImage) and isinstance(
reference_img, SpatialImage)
if conds:
if method is None:
return rigid_registration(floating_img, reference_img)
elif method is not None:
if method in poss_methods:
try:
from openalea.core.service.plugin import plugin_function
func = plugin_function('openalea.image', method)
if func is not None:
return func(floating_img, reference_img, **kwds)
except:
if method == 'rigid_registration':
trsf_out, res_image = rigid_registration(
floating_img, reference_img)
return trsf_out, res_image
elif method == 'affine_registration':
trsf_out, res_image = affine_registration(
floating_img, reference_img)
return trsf_out, res_image
elif method == 'deformable_registration':
trsf_out, res_image = deformable_registration(
floating_img, reference_img)
return trsf_out, res_image
else:
print('Available methods :'), poss_methods
raise NotImplementedError(method)
else:
raise TypeError(
'Floating image and Refernece image must be a SpatialImage')
return
def linear_filtering(input_image, method=None, **kwds):
"""
Linear filtering plugin. Available methods are :
* gaussian_smoothing
* gradient
* gradient_modulus
* hessian
* laplacian
* gradient_hessian
* gradient_laplacian
* zero_crossings_hessian
* zero_crossings_laplacian
Parameters
----------
:param *SpatialImage* input_image: input *SpatialImage*
:param str method: used method (example: 'gaussian_smoothing')
Returns
----------
:return: ``SpatialImage`` instance -- image and metadata
Example
----------
>>> from timagetk.util import data, data_path
>>> from timagetk.plugins import linear_filtering
>>> image_path = data_path('time_0_cut.inr')
>>> input_image = data(image_path)
>>> gauss_image = linear_filtering(input_image, std_dev=2.0, method='gaussian_smoothing')
>>> grad_mod_image = linear_filtering(input_image, method='gradient_modulus')
>>> lap_image = linear_filtering(input_image, method='laplacian')
"""
poss_methods = ['gaussian_smoothing', 'gradient', 'gradient_modulus', 'hessian', 'laplacian',
'gradient_hessian', 'gradient_laplacian', 'zero_crossings_hessian',
'zero_crossings_laplacian']
conds = isinstance(input_image, SpatialImage)
if conds:
if method is None:
return linear_filtering_gaussian_smoothing(input_image)
elif method is not None:
if method in poss_methods:
try:
from openalea.core.service.plugin import plugin_function
func = plugin_function('openalea.image', method)
if func is not None:
return func(input_image, **kwds)
except:
if method=='gaussian_smoothing':
std_dev_val = kwds.get('std_dev', None)
return linear_filtering_gaussian_smoothing(input_image, std_dev=std_dev_val)
elif method=='gradient':
return linear_filtering_gradient(input_image)
elif method=='gradient_modulus':
return linear_filtering_gradient_modulus(input_image)
elif method=='hessian':
return linear_filtering_hessian(input_image)
elif method=='laplacian':
return linear_filtering_laplacian(input_image)
elif method=='gradient_hessian':
return linear_filtering_gradient_hessian(input_image)
elif method=='gradient_laplacian':
return linear_filtering_gradient_laplacian(input_image)
elif method=='zero_crossings_hessian':
return linear_filtering_zero_crossings_hessian(input_image)
elif method=='zero_crossings_laplacian':
return linear_filtering_zero_crossings_laplacian(input_image)
else:
print('Available methods :'), poss_methods
raise NotImplementedError(method)
else:
raise TypeError('Input image must be a SpatialImage')
return
def morphology(input_image, method=None, **kwds):
"""
Grayscale morphology plugin. Available methods are :
* erosion
* dilation
* opening
* closing
* morpho_gradient
* contrast
* hat_transform
* inverse_hat_transform
* oc_alternate_sequential_filter
* co_alternate_sequential_filter
* coc_alternate_sequential_filter
* oco_alternate_sequential_filter
Parameters
----------
:param *SpatialImage* input_image: input *SpatialImage*
:param str method: used method (example: 'erosion')
Returns
----------
:return: ``SpatialImage`` instance -- image and metadata
Example
----------
>>> from timagetk.util import data, data_path
>>> from timagetk.plugins import morphology
>>> image_path = data_path('time_0_cut.inr')
>>> input_image = data(image_path)
>>> dilation_image = morphology(input_image, radius=2, iterations=2, method='dilation')
>>> oc_asf_image = morphology(input_image, max_radius=3, method='oc_alternate_sequential_filter')
"""
poss_methods = [
'erosion', 'dilation', 'opening', 'closing', 'morpho_gradient',
'contrast', 'hat_transform', 'inverse_hat_transform',
'oc_alternate_sequential_filter', 'co_alternate_sequential_filter',
'coc_alternate_sequential_filter', 'oco_alternate_sequential_filter'
]
conds = isinstance(input_image, SpatialImage)
if conds:
if method is None:
return morphology_erosion(input_image)
elif method is not None:
if method in poss_methods:
try:
from openalea.core.service.plugin import plugin_function
func = plugin_function('openalea.image', method)
if func is not None:
return func(input_image, **kwds)
except:
radius_val = kwds.get('radius', None)
it_val = kwds.get('iterations', None)
max_radius_val = kwds.get('max_radius', None)
if method == 'erosion':
return morphology_erosion(input_image,
radius=radius_val,
iterations=it_val)
elif method == 'dilation':
return morphology_dilation(input_image,
radius=radius_val,
iterations=it_val)
elif method == 'opening':
return morphology_opening(input_image,
radius=radius_val,
iterations=it_val)
elif method == 'closing':
return morphology_closing(input_image,
radius=radius_val,
iterations=it_val)
elif method == 'morpho_gradient':
return morphology_gradient(input_image,
radius=radius_val,
iterations=it_val)
elif method == 'contrast':
return morphology_contrast(input_image,
radius=radius_val,
iterations=it_val)
elif method == 'hat_transform':
return morphology_hat_transform(input_image,
radius=radius_val,
iterations=it_val)
elif method == 'inverse_hat_transform':
return morphology_inverse_hat_transform(
input_image, radius=radius_val, iterations=it_val)
elif method == 'oc_alternate_sequential_filter':
return morphology_oc_alternate_sequential_filter(
input_image, max_radius=max_radius_val)
elif method == 'co_alternate_sequential_filter':
return morphology_co_alternate_sequential_filter(
input_image, max_radius=max_radius_val)
elif method == 'coc_alternate_sequential_filter':
return morphology_coc_alternate_sequential_filter(
input_image, max_radius=max_radius_val)
elif method == 'oco_alternate_sequential_filter':
return morphology_oco_alternate_sequential_filter(
input_image, max_radius=max_radius_val)
else:
print('Available methods :'), poss_methods
raise NotImplementedError(method)
else:
raise TypeError('Input image must be a SpatialImage')
return
