def process_fov(fov: FieldOfView, codebook: Codebook) -> DecodedIntensityTable:
"""Process a single field of view of ISS data
Parameters
----------
fov : FieldOfView
the field of view to process
codebook : Codebook
the Codebook to use for decoding
Returns
-------
DecodedSpots :
tabular object containing the locations of detected spots.
"""
# note the structure of the 5D tensor containing the raw imaging data
imgs = fov.get_image(FieldOfView.PRIMARY_IMAGES)
dots = fov.get_image("dots")
nuclei = fov.get_image("nuclei")
print("Learning Transform")
learn_translation = LearnTransform.Translation(reference_stack=dots,
axes=Axes.ROUND,
upsampling=1000)
transforms_list = learn_translation.run(
imgs.reduce({Axes.CH, Axes.ZPLANE}, func="max"))
print("Applying transform")
warp = ApplyTransform.Warp()
registered_imgs = warp.run(imgs,
transforms_list=transforms_list,
verbose=True)
print("Filter WhiteTophat")
filt = Filter.WhiteTophat(masking_radius=15, is_volume=False)
filtered_imgs = filt.run(registered_imgs, verbose=True)
filt.run(dots, verbose=True, in_place=True)
filt.run(nuclei, verbose=True, in_place=True)
print("Detecting")
detector = FindSpots.BlobDetector(
min_sigma=1,
max_sigma=10,
num_sigma=30,
threshold=0.01,
measurement_type='mean',
)
dots_max = dots.reduce((Axes.ROUND, Axes.ZPLANE),
func="max",
module=FunctionSource.np)
spots = detector.run(image_stack=filtered_imgs, reference_image=dots_max)
print("Decoding")
decoder = DecodeSpots.PerRoundMaxChannel(codebook=codebook)
decoded = decoder.run(spots=spots)
return decoded
def find_spots(imgs, dots):
p = FindSpots.BlobDetector(
min_sigma=1,
max_sigma=10,
num_sigma=30,
threshold=0.01,
measurement_type='mean',
)
intensities = p.run(image_stack=imgs, reference_image=dots)
return intensities
def iss_pipeline(fov, codebook):
primary_image = fov.get_image(starfish.FieldOfView.PRIMARY_IMAGES)
# register the raw image
learn_translation = LearnTransform.Translation(
reference_stack=fov.get_image('dots'), axes=Axes.ROUND, upsampling=100)
transforms_list = learn_translation.run(
primary_image.reduce({Axes.CH, Axes.ZPLANE}, func="max"))
warp = ApplyTransform.Warp()
registered = warp.run(primary_image,
transforms_list=transforms_list,
in_place=False,
verbose=True)
# filter raw data
masking_radius = 15
filt = Filter.WhiteTophat(masking_radius, is_volume=False)
filtered = filt.run(registered, verbose=True, in_place=False)
bd = FindSpots.BlobDetector(
min_sigma=1,
max_sigma=10,
num_sigma=30,
threshold=0.01,
measurement_type='mean',
)
# detect spots using laplacian of gaussians approach
dots_max = fov.get_image('dots').reduce((Axes.ROUND, Axes.ZPLANE),
func="max",
module=FunctionSource.np)
# locate spots in a reference image
spots = bd.run(reference_image=dots_max, image_stack=filtered)
# decode the pixel traces using the codebook
decoder = DecodeSpots.PerRoundMaxChannel(codebook=codebook)
decoded = decoder.run(spots=spots)
# segment cells
seg = Segment.Watershed(
nuclei_threshold=.16,
input_threshold=.22,
min_distance=57,
)
label_image = seg.run(primary_image, fov.get_image('dots'))
# assign spots to cells
ta = AssignTargets.Label()
assigned = ta.run(label_image, decoded)
return assigned, label_image
masking_radius = 15
filt = Filter.WhiteTophat(masking_radius, is_volume=False)
filt.run(imgs, in_place=True)
filt.run(dots, in_place=True)
# register primary images to reference round
learn_translation = LearnTransform.Translation(reference_stack=dots,
axes=Axes.ROUND,
upsampling=1000)
transforms_list = learn_translation.run(
imgs.reduce({Axes.CH, Axes.ZPLANE}, func="max"))
warp = ApplyTransform.Warp()
warp.run(imgs, transforms_list=transforms_list, in_place=True)
# run blob detector on dots (reference image with every spot)
bd = FindSpots.BlobDetector(
min_sigma=1,
max_sigma=10,
num_sigma=30,
threshold=0.01,
measurement_type='mean',
)
dots_max = dots.reduce((Axes.ROUND, Axes.ZPLANE), func="max")
spots = bd.run(image_stack=imgs, reference_image=dots_max)
# Decode spots with PerRoundMaxChannel
from starfish.spots import DecodeSpots
decoder = DecodeSpots.PerRoundMaxChannel(
codebook=experiment.codebook,
trace_building_strategy=TraceBuildingStrategies.EXACT_MATCH)
decoded_intensities = decoder.run(spots=spots)
fov = experiment.fov()
imgs = fov.get_image(FieldOfView.PRIMARY_IMAGES) # primary images
dots = fov.get_image("dots") # reference round where every spot labeled with fluorophore
# filter raw data
masking_radius = 15
filt = Filter.WhiteTophat(masking_radius, is_volume=False)
filt.run(imgs, in_place=True)
filt.run(dots, in_place=True)
# register primary images to reference round
learn_translation = LearnTransform.Translation(reference_stack=dots, axes=Axes.ROUND, upsampling=1000)
transforms_list = learn_translation.run(imgs.reduce({Axes.CH, Axes.ZPLANE}, func="max"))
warp = ApplyTransform.Warp()
warp.run(imgs, transforms_list=transforms_list, in_place=True)
# view dots to estimate radius of spots: radius range from 1.5 to 4 pixels
imshow_plane(dots, {Axes.X: (500, 550), Axes.Y: (600, 650)})
# run blob detector with dots as reference image
# following guideline of sigma = radius/sqrt(2) for 2D images
# threshold is set conservatively low
bd = FindSpots.BlobDetector(
min_sigma=1,
max_sigma=3,
num_sigma=10,
threshold=0.01,
is_volume=False,
measurement_type='mean',
)
spots = bd.run(image_stack=imgs, reference_image=dots)
})
####################################################################################################
# The ``dots`` reference image shows spots are approximately 10 pixels in diameter and can be
# tightly packed together. This helped inform the parameter settings of the spot finders below.
# However, the accuracy can always be improved by further tuning parameters. For example,
# if low intensity background noise is being detected as spots, increasing values for
# ``threshold``, ``stringency``, ``min_mass``, and ``percentile`` can remove them. If large spots
# are not missed, increasing values such as ``max_sigma``, ``max_obj_area``, ``spot_diameter``,
# and ``max_size`` could include them. Moreover, signal enhancement and background reduction
# prior to this step can also improve accuracy of spot finding.
bd = FindSpots.BlobDetector(
min_sigma=2,
max_sigma=6,
num_sigma=20,
threshold=0.1,
is_volume=True,
measurement_type='mean',
)
lmp = FindSpots.LocalMaxPeakFinder(min_distance=2,
stringency=8,
min_obj_area=6,
max_obj_area=600,
is_volume=True)
tlmpf = FindSpots.TrackpyLocalMaxPeakFinder(
spot_diameter=11,
min_mass=0.2,
max_size=8,
separation=3,
# Finally, a local blob detector that finds spots in each (z, y, x) volume separately is applied.
# The user selects an "anchor round" and spots found in all channels of that round are used to
# seed a local search across other rounds and channels. The closest spot is selected,
# and any spots outside the search radius (here 10 pixels) is discarded.
#
# The Spot finder returns an IntensityTable containing all spots from round zero. Note that many
# of the spots do not identify spots in other rounds and channels and will therefore fail
# decoding. Because of the stringency built into the STARmap codebook, it is OK to be relatively
# permissive with the spot finding parameters for this assay.
import numpy as np
from starfish.spots import FindSpots
bd = FindSpots.BlobDetector(min_sigma=1,
max_sigma=8,
num_sigma=10,
threshold=np.percentile(
np.ravel(stack.xarray.values), 95),
exclude_border=2)
spots = bd.run(scaled)
###################################################################################################
# Decode spots
# ------------
# Next, spots are decoded. There is really no good way to display 3-d spot detection in 2-d planes,
# so we encourage you to grab this notebook and uncomment the below lines.
from starfish.spots import DecodeSpots
from starfish.types import TraceBuildingStrategies
decoder = DecodeSpots.PerRoundMaxChannel(
def process_fov(field_num: int, experiment_str: str):
"""Process a single field of view of ISS data
Parameters
----------
field_num : int
the field of view to process
experiment_str : int
path of experiment json file
Returns
-------
DecodedSpots :
tabular object containing the locations of detected spots.
"""
fov_str: str = f"fov_{int(field_num):03d}"
# load experiment
experiment = starfish.Experiment.from_json(experiment_str)
print(f"loading fov: {fov_str}")
fov = experiment[fov_str]
# note the structure of the 5D tensor containing the raw imaging data
imgs = fov.get_image(FieldOfView.PRIMARY_IMAGES)
dots = fov.get_image("dots")
nuclei = fov.get_image("nuclei")
print("Learning Transform")
learn_translation = LearnTransform.Translation(reference_stack=dots,
axes=Axes.ROUND,
upsampling=1000)
transforms_list = learn_translation.run(
imgs.reduce({Axes.CH, Axes.ZPLANE}, func="max"))
print("Applying transform")
warp = ApplyTransform.Warp()
registered_imgs = warp.run(imgs,
transforms_list=transforms_list,
in_place=True,
verbose=True)
print("Filter WhiteTophat")
filt = Filter.WhiteTophat(masking_radius=15, is_volume=False)
filtered_imgs = filt.run(registered_imgs, verbose=True, in_place=True)
filt.run(dots, verbose=True, in_place=True)
filt.run(nuclei, verbose=True, in_place=True)
print("Detecting")
detector = FindSpots.BlobDetector(
min_sigma=1,
max_sigma=10,
num_sigma=30,
threshold=0.01,
measurement_type='mean',
)
dots_max_projector = Filter.Reduce((Axes.ROUND, Axes.ZPLANE),
func=FunctionSource.np("max"))
dots_max = dots_max_projector.run(dots)
spots = detector.run(image_stack=filtered_imgs, reference_image=dots_max)
decoder = DecodeSpots.PerRoundMaxChannel(codebook=experiment.codebook)
decoded = decoder.run(spots=spots)
df = decoded.to_decoded_dataframe()
return df