Measure fluorescence intensity at the nuclear envelope¶
This example reproduces a well-established workflow in bioimage data analysis for measuring the fluorescence intensity localized to the nuclear envelope, in a time sequence of cell images (each with two channels and two spatial dimensions) which shows a process of protein re-localization from the cytoplasmic area to the nuclear envelope. This biological application was first presented by Andrea Boni and collaborators in ; it was used in a textbook by Kota Miura  as well as in other works (, ). In other words, we port this workflow from ImageJ Macro to Python with scikit-image.
import matplotlib.pyplot as plt import numpy as np import plotly.io import plotly.express as px from scipy import ndimage as ndi from skimage import ( filters, measure, morphology, segmentation ) from skimage.data import protein_transport
We start with a single cell/nucleus to construct the workflow.
shape: (15, 2, 180, 183)
The dataset is a 2D image stack with 15 frames (time points) and 2 channels.
To begin with, let us consider the first channel of the first image (step
a) in the figure below).
Segment the nucleus rim¶
Let us apply a Gaussian low-pass filter to this image in order to smooth it
Next, we segment the nuclei, finding the threshold between the background
and foreground with Otsu’s method: We get a binary image (step
then fill the holes in the objects (step
Following the original workflow, let us remove objects which touch the image
c-2)). Here, we can see that part of another nucleus was
touching the bottom right-hand corner.
We compute both the morphological dilation of this binary image
d)) and its morphological erosion (step
Finally, we subtract the eroded from the dilated to get the nucleus rim
f)). This is equivalent to selecting the pixels which are in
dilate, but not in
Let us visualize these processing steps in a sequence of subplots.
fig, ax = plt.subplots(2, 4, figsize=(12, 6), sharey=True) ax[0, 0].imshow(image_t_0_channel_0, cmap=plt.cm.gray) ax[0, 0].set_title('a) Raw') ax[0, 1].imshow(smooth, cmap=plt.cm.gray) ax[0, 1].set_title('b) Blur') ax[0, 2].imshow(thresh, cmap=plt.cm.gray) ax[0, 2].set_title('c) Threshold') ax[0, 3].imshow(fill, cmap=plt.cm.gray) ax[0, 3].set_title('c-1) Fill in') ax[1, 0].imshow(clear, cmap=plt.cm.gray) ax[1, 0].set_title('c-2) Keep one nucleus') ax[1, 1].imshow(dilate, cmap=plt.cm.gray) ax[1, 1].set_title('d) Dilate') ax[1, 2].imshow(erode, cmap=plt.cm.gray) ax[1, 2].set_title('e) Erode') ax[1, 3].imshow(mask, cmap=plt.cm.gray) ax[1, 3].set_title('f) Nucleus Rim') for a in ax.ravel(): a.set_axis_off() fig.tight_layout()
Apply the segmented rim as a mask¶
Now that we have segmented the nuclear membrane in the first channel, we use it as a mask to measure the intensity in the second channel.
image_t_0_channel_1 = image_sequence[0, 1, :, :] selection = np.where(mask, image_t_0_channel_1, 0) fig, (ax0, ax1) = plt.subplots(1, 2, figsize=(12, 6), sharey=True) ax0.imshow(image_t_0_channel_1) ax0.set_title('Second channel (raw)') ax0.set_axis_off() ax1.imshow(selection) ax1.set_title('Selection') ax1.set_axis_off() fig.tight_layout()
Measure the total intensity¶
The mean intensity is readily available as a region property in a labeled image.
We may want to check that the value for the total intensity
can be recovered from:
Process the entire image sequence¶
Instead of iterating the workflow for each time point, we process the multidimensional dataset directly (except for the thresholding step). Indeed, most scikit-image functions support nD images.
Alternatively, we could compute
thresh_values without using a list
comprehension, by reshaping
smooth_seq to make it 2D (where the first
dimension still corresponds to time points, but the second and last
dimension now contains all pixel values), and applying the thresholding
function on the image sequence along its second axis:
We use the following flat structuring element for morphological
np.newaxis is used to prepend an axis of size 1 for time):
array([[[False, True, False], [ True, True, True], [False, True, False]]])
This way, each frame is processed independently (pixels from consecutive frames are never spatial neighbors).
When clearing objects which touch the image border, we want to make sure that the bottom (first) and top (last) frames are not considered as borders. In this case, the only relevant border is the edge at the greatest (x, y) values. This can be seen in 3D by running the following code:
border_mask = np.ones_like(fill_seq) border_mask[n_z // 2, -1, -1] = False clear_seq = segmentation.clear_border(fill_seq, mask=border_mask) dilate_seq = morphology.binary_dilation(clear_seq, footprint=footprint) erode_seq = morphology.binary_erosion(clear_seq, footprint=footprint) mask_sequence = np.logical_and(dilate_seq, ~erode_seq)
Let us give each mask (corresponding to each time point) a different label,
running from 1 to 15. We use
np.min_scalar_type to determine the
minimum-size integer dtype needed to represent the number of time points:
Let us compute the region properties of interest for all these labeled regions.
props = measure.regionprops_table( mask_sequence, intensity_image=image_sequence[:, 1, :, :], properties=('label', 'area', 'intensity_mean') ) np.testing.assert_array_equal(props['label'], np.arange(n_z) + 1) fluorescence_change = [props['area'][i] * props['intensity_mean'][i] for i in range(n_z)] fluorescence_change /= fluorescence_change # normalization fig, ax = plt.subplots() ax.plot(fluorescence_change, 'rs') ax.grid() ax.set_xlabel('Time point') ax.set_ylabel('Normalized total intensity') ax.set_title('Change in fluorescence intensity at the nuclear envelope') fig.tight_layout() plt.show()
Reassuringly, we find the expected result: The total fluorescence intensity at the nuclear envelope increases 1.3-fold in the initial five time points, and then becomes roughly constant.
Total running time of the script: ( 0 minutes 1.007 seconds)