def run(
self,
image_stack: ImageStack,
reference_image: Optional[ImageStack] = None,
n_processes: Optional[int] = None,
*args,
**kwargs
) -> SpotFindingResults:
"""
Find spots in the given ImageStack using a local maxima finding algorithm.
If a reference image is provided the spots will be detected there then measured
across all rounds and channels in the corresponding ImageStack. If a reference_image
is not provided spots will be detected _independently_ in each channel. This assumes
a non-multiplex imaging experiment, as only one (ch, round) will be measured for each spot.
Parameters
----------
image_stack : ImageStack
ImageStack where we find the spots in.
reference_image : Optional[ImageStack]
(Optional) a reference image. If provided, spots will be found in this image, and then
the locations that correspond to these spots will be measured across each channel.
n_processes : Optional[int] = None,
Number of processes to devote to spot finding.
"""
spot_finding_method = partial(self.image_to_spots, **self.kwargs)
if reference_image:
shape = reference_image.shape
assert shape[Axes.ROUND] == 1
assert shape[Axes.CH] == 1
spot_attributes_lists = reference_image.transform(
func=spot_finding_method,
group_by=determine_axes_to_group_by(self.is_volume),
n_processes=n_processes
)
spot_attributes_lists = combine_spot_attributes_by_round_channel(spot_attributes_lists)
assert len(spot_attributes_lists) == 1
results = spot_finding_utils.measure_intensities_at_spot_locations_across_imagestack(
data_image=image_stack,
reference_spots=spot_attributes_lists[0][0],
measurement_function=self.measurement_function)
else:
spot_attributes_lists = image_stack.transform(
func=spot_finding_method,
group_by=determine_axes_to_group_by(self.is_volume),
n_processes=n_processes
)
spot_attributes_lists = combine_spot_attributes_by_round_channel(spot_attributes_lists)
results = SpotFindingResults(imagestack_coords=image_stack.xarray.coords,
log=image_stack.log,
spot_attributes_list=spot_attributes_lists)
return results
def run(
self,
image_stack: ImageStack,
reference_image: Optional[ImageStack] = None,
n_processes: Optional[int] = None,
*args,
) -> SpotFindingResults:
"""
Find spots in the given ImageStack using a gaussian blob finding algorithm.
If a reference image is provided the spots will be detected there then measured
across all rounds and channels in the corresponding ImageStack. If a reference_image
is not provided spots will be detected _independently_ in each channel. This assumes
a non-multiplex imaging experiment, as only one (ch, round) will be measured for each spot.
Parameters
----------
image_stack : ImageStack
ImageStack where we find the spots in.
reference_image : Optional[ImageStack]
(Optional) a reference image. If provided, spots will be found in this image, and then
the locations that correspond to these spots will be measured across each channel.
n_processes : Optional[int] = None,
Number of processes to devote to spot finding.
"""
spot_finding_method = partial(self.image_to_spots, *args)
if reference_image:
data_image = reference_image._squeezed_numpy(
*{Axes.ROUND, Axes.CH})
if self.detector_method is blob_doh and data_image.ndim > 2:
raise ValueError("blob_doh only support 2d images")
reference_spots = spot_finding_method(data_image)
results = spot_finding_utils.measure_intensities_at_spot_locations_across_imagestack(
data_image=image_stack,
reference_spots=reference_spots,
measurement_function=self.measurement_function)
else:
if self.detector_method is blob_doh and self.is_volume:
raise ValueError("blob_doh only support 2d images")
spot_attributes_list = image_stack.transform(
func=spot_finding_method,
group_by=determine_axes_to_group_by(self.is_volume),
n_processes=n_processes)
results = SpotFindingResults(
imagestack_coords=image_stack.xarray.coords,
log=image_stack.log,
spot_attributes_list=spot_attributes_list)
return results
def run(
self,
image_stack: ImageStack,
reference_image: Optional[ImageStack] = None,
n_processes: Optional[int] = None,
*args,
) -> SpotFindingResults:
"""
Find spots.
Parameters
----------
image_stack : ImageStack
ImageStack where we find the spots in.
reference_image : xr.DataArray
(Optional) a reference image. If provided, spots will be found in this image, and then
the locations that correspond to these spots will be measured across each channel.
n_processes : Optional[int] = None,
Number of processes to devote to spot finding.
"""
spot_finding_method = partial(self.image_to_spots, *args)
if reference_image:
data_image = reference_image._squeezed_numpy(
*{Axes.ROUND, Axes.CH})
reference_spots = spot_finding_method(data_image)
results = spot_finding_utils.measure_intensities_at_spot_locations_across_imagestack(
image_stack,
reference_spots,
measurement_function=self.measurement_function,
radius_is_gyration=self.radius_is_gyration)
else:
spot_attributes_list = image_stack.transform(
func=spot_finding_method,
group_by=determine_axes_to_group_by(self.is_volume),
n_processes=n_processes)
results = SpotFindingResults(
imagestack_coords=image_stack.xarray.coords,
log=image_stack.log,
spot_attributes_list=spot_attributes_list)
return results
