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