def run(
self,
stack: ImageStack,
*args,
) -> Optional[ImageStack]:
"""Map from input to output by applying a specified function to the input.
Parameters
----------
stack : ImageStack
Stack to be filtered.
Returns
-------
Optional[ImageStack] :
If in-place is False, return the results of filter as a new stack. Otherwise return
None
"""
# Apply the reducing function
return stack.apply(self.func,
*self.func_args,
group_by=self.group_by,
in_place=self.in_place,
clip_method=self.clip_method,
**self.func_kwargs)
def run(
self,
stack: ImageStack,
in_place: bool = False,
verbose: bool = False,
n_processes: Optional[int] = None,
*args,
) -> Optional[ImageStack]:
"""Perform filtering of an image stack
Parameters
----------
stack : ImageStack
Stack to be filtered.
in_place : bool
if True, process ImageStack in-place, otherwise return a new stack
verbose : bool
if True, report on filtering progress (default = False)
n_processes : Optional[int]
Number of parallel processes to devote to applying the filter. If None, defaults to
the result of os.cpu_count(). (default None)
Returns
-------
ImageStack :
If in-place is False, return the results of filter as a new stack. Otherwise return the
original stack.
"""
bandpass_ = partial(self._bandpass,
lshort=self.lshort,
llong=self.llong,
threshold=self.threshold,
truncate=self.truncate)
group_by = determine_axes_to_group_by(self.is_volume)
result = stack.apply(
bandpass_,
group_by=group_by,
in_place=in_place,
n_processes=n_processes,
level_method=self.level_method,
verbose=verbose,
)
return result
def run(
self,
stack: ImageStack,
in_place: bool = False,
verbose=False,
n_processes: Optional[int] = None,
*args,
) -> Optional[ImageStack]:
"""Perform filtering of an image stack
Parameters
----------
stack : ImageStack
Stack to be filtered.
in_place : bool
if True, process ImageStack in-place, otherwise return a new stack
verbose : bool
if True, report on the percentage completed during processing (default = False)
n_processes : Optional[int]
Number of parallel processes to devote to applying the filter. If None, defaults to
the result of os.cpu_count(). (default None)
Returns
-------
ImageStack :
If in-place is False, return the results of filter as a new stack. Otherwise return the
original stack.
"""
group_by = determine_axes_to_group_by(self.is_volume)
func = partial(
self._richardson_lucy_deconv,
iterations=self.num_iter, psf=self.psf
)
result = stack.apply(
func,
group_by=group_by,
verbose=verbose,
n_processes=n_processes,
in_place=in_place,
level_method=self.level_method,
)
return result
def run(self,
stack: ImageStack,
in_place: bool = False,
verbose: bool = False,
n_processes: Optional[int] = None,
*args) -> Optional[ImageStack]:
"""Perform filtering of an image stack
Parameters
----------
stack : ImageStack
Stack to be filtered.
in_place : bool
if True, process ImageStack in-place, otherwise return a new stack
verbose : bool
if True, report on filtering progress (default = False)
n_processes : Optional[int]
Number of parallel processes to devote to applying the filter.
If None, defaults to the result of os.cpu_count(). (default None)
Returns
-------
ImageStack :
If in-place is False, return the results of filter as a new stack.
Otherwise return the original stack.
"""
group_by = determine_axes_to_group_by(self.is_volume)
clip_value_to_zero = partial(
self._clip_value_to_zero,
v_min=self.v_min,
v_max=self.v_max,
)
result = stack.apply(
clip_value_to_zero,
group_by=group_by,
verbose=verbose,
in_place=in_place,
n_processes=n_processes,
level_method=self.level_method,
)
return result
def run(
self,
stack: ImageStack,
in_place: bool = False,
verbose: bool = False,
n_processes: Optional[int] = None,
*args,
) -> ImageStack:
"""Perform filtering of an image stack
Parameters
----------
stack : ImageStack
Stack to be filtered.
in_place : bool
if True, process ImageStack in-place, otherwise return a new stack
verbose : bool
if True, report on filtering progress (default = False)
n_processes : Optional[int]
Number of parallel processes to devote to applying the filter. If None, defaults to
the result of os.cpu_count(). (default None)
Returns
-------
ImageStack :
If in-place is False, return the results of filter as a new stack. Otherwise return the
original stack.
"""
if verbose:
print("Calculating reference distribution...")
reference_image = self._compute_reference_distribution(stack)
apply_function = partial(self._match_histograms,
reference=reference_image)
result = stack.apply(apply_function,
group_by=self.group_by,
verbose=verbose,
in_place=in_place,
n_processes=n_processes)
return result
def run(
self,
stack: ImageStack,
in_place: bool = False,
verbose: bool = False,
n_processes: Optional[int] = None,
*args,
) -> ImageStack:
"""Perform filtering of an image stack
Parameters
----------
stack : ImageStack
Stack to be filtered.
in_place : bool
if True, process ImageStack in-place, otherwise return a new stack
verbose : bool
if True, report on filtering progress (default = False)
n_processes : Optional[int]
Number of parallel processes to devote to applying the filter. If None, defaults to
the result of os.cpu_count(). (default None)
Returns
-------
ImageStack :
If in-place is False, return the results of filter as a new stack. Otherwise return the
original stack.
"""
group_by = {Axes.ROUND, Axes.ZPLANE}
unmix = partial(self._unmix, coeff_mat=self.coeff_mat)
result = stack.apply(
unmix,
group_by=group_by,
verbose=verbose,
in_place=in_place,
n_processes=n_processes,
clip_method=self.clip_method,
)
return result
def run(
self,
stack: ImageStack,
in_place: bool = False,
verbose: bool = False,
n_processes: Optional[int] = None,
*args,
) -> Optional[ImageStack]:
"""Perform filtering of an image stack
Parameters
----------
stack : ImageStack
Stack to be filtered.
in_place : bool
if True, process ImageStack in-place, otherwise return a new stack
verbose : bool
if True, report on filtering progress (default = False)
n_processes : Optional[int]
Number of parallel processes to devote to applying the filter. If None, defaults to
the result of os.cpu_count(). (default None)
Returns
-------
ImageStack :
If in-place is False, return the results of filter as a new stack. Otherwise return the
original stack.
"""
group_by = determine_axes_to_group_by(self.is_volume)
apply_filtering: Callable = partial(self._gaussian_laplace,
sigma=self.sigma)
return stack.apply(apply_filtering,
group_by=group_by,
verbose=verbose,
in_place=in_place,
n_processes=n_processes,
clip_method=self.clip_method)
def run(
self,
stack: ImageStack,
in_place: bool = False,
verbose: bool = False,
n_processes: Optional[int] = None,
*args,
) -> ImageStack:
"""Perform filtering of an image stack
Parameters
----------
stack : ImageStack
Stack to be filtered.
in_place : bool
if True, process ImageStack in-place, otherwise return a new stack
verbose : bool
If True, report on the percentage completed (default = False) during processing
n_processes : Optional[int]
Number of parallel processes to devote to applying the filter. If None, defaults to
the result of os.cpu_count(). (default None)
Returns
-------
ImageStack :
If in-place is False, return the results of filter as a new stack. Otherwise return the
original stack.
"""
group_by = determine_axes_to_group_by(self.is_volume)
result = stack.apply(self._white_tophat,
group_by=group_by,
verbose=verbose,
in_place=in_place,
n_processes=n_processes,
clip_method=self.clip_method)
return result
