def random_image_set(x, y, colors, n):
"""
Creates a image set
:param x: The width of the image
:param y: The height of the image
:param colors: IF the image needs colors
:param n: The number of images
:return: A ImageSet
"""
max_value = 255
rand_im = np.random.rand(x, y)
exposure_im = np.zeros((n, x, y), dtype=int)
if colors:
rand_im = np.random.rand(x, y, 3)
exposure_im = np.zeros((n, x, y, 3), dtype=int)
rand_im = rand_im
exposures = np.zeros(n)
for i in range(1, n + 1):
exposure_im[i - 1] = (rand_im * max_value * 2**(i - 1)).astype(int)
exposure_im[i - 1][exposure_im[i - 1] > max_value] = max_value
exposures[i - 1] = 2**(i - 1)
im_set = ImageSet(exposure_im)
im_set.shutter_speed = np.log(exposures)
im_set.original_shape = rand_im.shape
return rand_im, im_set
def test_compute_spots_peripheral_distance(self):
image_set = ImageSet(self.repo, path_list=['mrna/arhgdia/2h/'])
result = image_set.compute_spots_peripheral_distance()
total_sum=0
for res in result:
total_sum += np.sum(res)
self.assertEqual(total_sum, 20030.0)
def compute_stability(gene, bootstrap=500, force2D=True):
total_mads = []
imageset = ImageSet(analysis_repo, ["mrna/" + gene + "/"], force2D=force2D)
spots_peripheral_distances = imageset.compute_spots_peripheral_distance()
peripheral_profiles = np.zeros((len(spots_peripheral_distances), 10))
for j in range(len(spots_peripheral_distances)):
for i in range(0, 10):
peripheral_profiles[j, i] = float(
len(
np.where((spots_peripheral_distances[j] >= (
(i * 10) + 1)) & (spots_peripheral_distances[j] <=
(i + 1) * 10))[0]) /
float(len(spots_peripheral_distances[j])))
logger.info(
"Compute mean_absolute_deviation for randomly selected images in {} dataset",
gene)
for j in tqdm.tqdm(range(bootstrap), desc="Simulation"):
mads = []
for i in range(1, len(imageset.images) - 1):
arr = peripheral_profiles[np.random.choice(
peripheral_profiles.shape[0], i, replace=True)]
rand_idx = randint(0, peripheral_profiles.shape[0] - 1)
mean_arr = np.mean(arr, axis=0)
arr_diff = mean_arr - peripheral_profiles[rand_idx, :]
mse = helpers.mean_absolute_deviation(arr_diff)
mads.append(mse)
total_mads.append(mads)
return total_mads
def test_compute_normalised_quadrant_densities_protein(self):
image_set = ImageSet(self.repo, path_list=['protein/arhgdia/2h/'])
res = image_set.compute_normalised_quadrant_densities()
mtoc_density = res[res[:, 1] == 1].sum() / len(res[res[:, 1] == 1])
non_mtoc_density = res[res[:, 1] == 0].sum() / len(res[res[:, 1] == 0])
self.assertAlmostEqual(mtoc_density, 1.98375276421, places=3)
self.assertAlmostEqual(non_mtoc_density, 1.0445809579196, places=3)
def compute_degree_of_clustering(genes_list, analysis_repo, molecule_type):
gene2_degree_of_clustering = {}
gene2median_degree_of_clustering = {}
gene2error_degree_of_clustering = {}
gene2confidence_interval = {}
degrees_of_clustering = []
for gene in genes_list:
image_set = ImageSet(analysis_repo,
['{0}/{1}/'.format(molecule_type, gene)])
d_of_c = np.array(image_set.compute_degree_of_clustering())
degrees_of_clustering.append(d_of_c)
for gene, degree_of_clustering in zip(genes_list, degrees_of_clustering):
degree_of_clustering = np.log(degree_of_clustering)
gene2_degree_of_clustering[gene] = degree_of_clustering
gene2median_degree_of_clustering[gene] = np.median(
degree_of_clustering)
# Standard error and CI computation
gene2error_degree_of_clustering[gene] = helpers.sem(
degree_of_clustering, factor=0)
lower, higher = helpers.median_confidence_interval(
degree_of_clustering)
gene2confidence_interval[gene] = [lower, higher]
return gene2_degree_of_clustering, gene2median_degree_of_clustering, gene2error_degree_of_clustering, gene2confidence_interval
def compute_transcript_by_cell_area(analysis_repo, gene, timepoints):
transcript_by_cell_area = {"total_transcript": [], "cell_area": []}
for timepoint in timepoints:
image_set = ImageSet(analysis_repo, [f"{'mrna'}/{gene}/{timepoint}/"], force2D=False)
[transcript_by_cell_area["total_transcript"].append(image.compute_cytoplasmic_total_spots()) for image in image_set.get_images()]
[transcript_by_cell_area["cell_area"].append(image.compute_cell_area()) for image in image_set.get_images()]
return pd.DataFrame(transcript_by_cell_area)
def plot_dynamic_barplot(analysis_repo):
'''
Formats the data and calls the plotting function
'''
plot_colors = constants.analysis_config['PLOT_COLORS']
# paired mRNA-protein barplots, so we go through proteins (we have less proteins than mRNA)
tp_mrna = constants.dataset_config['TIMEPOINTS_MRNA']
tp_proteins = constants.dataset_config['TIMEPOINTS_PROTEIN']
all_timepoints = np.sort(list(set(tp_mrna) | set(tp_proteins)))
for i, gene in enumerate(constants.analysis_config['PROTEINS']):
df = pd.DataFrame(
columns=["Molecule", "Timepoint", "d_of_c", "error", "CI"])
for molecule, timepoints in zip(["mrna", "protein"],
[tp_mrna, tp_proteins]):
for j, tp in enumerate(all_timepoints):
if tp not in timepoints:
df = df.append(
{
"Molecule": molecule,
"Timepoint": tp,
"error": 0,
"CI": [0, 0],
"d_of_c": 0
},
ignore_index=True)
continue
image_set = ImageSet(
analysis_repo, ["{0}/{1}/{2}/".format(molecule, gene, tp)])
degree_of_clustering = np.log(
image_set.compute_degree_of_clustering(
)) # * factor[gene][molecule][j]
err = helpers.sem(degree_of_clustering, factor=6)
lower, higher = helpers.median_confidence_interval(
degree_of_clustering)
df = df.append(
{
"Molecule": molecule,
"Timepoint": tp,
"error": err,
"CI": [lower, higher],
"d_of_c": degree_of_clustering
},
ignore_index=True)
df = df.sort_values('Timepoint')
df = df.groupby('Molecule').apply(mean_column)
my_pal = {
"mrna": str(plot_colors[i]),
"protein": str(color_variant(plot_colors[i], +80))
}
tgt_image_name = constants.analysis_config[
'DYNAMIC_FIGURE_NAME_FORMAT'].format(gene=gene)
tgt_fp = pathlib.Path(
constants.analysis_config['FIGURE_OUTPUT_PATH'].format(
root_dir=global_root_dir), tgt_image_name)
plot.bar_profile_median_timepoints(df,
palette=my_pal,
figname=tgt_fp,
fixed_yscale=15)
def test_compute_volumes_from_periphery(self):
image_set = ImageSet(self.repo, path_list=['mrna/arhgdia/3h/'])
self.assertEqual(len(image_set.images), 5, "Expected 5 images")
peripheral_volumes = image_set.compute_volumes_from_periphery()
self.assertEqual(peripheral_volumes.shape, (5, 100))
cytoplasmic_volumes = [img.compute_cytoplasmic_volume() for img in image_set.images]
self.assertTrue(np.allclose(peripheral_volumes[:, 99], np.array(cytoplasmic_volumes)))
self.assertAlmostEqual(peripheral_volumes.sum(), 121874.96804733, places=5)
def test_compute_spots_signal_from_periphery(self):
image_set = ImageSet(self.repo, path_list=['mrna/arhgdia/2h/'])
self.assertEqual(len(image_set.images), 5, "Expected 5 images")
peripheral_signals = image_set.compute_signal_from_periphery()
self.assertEqual(peripheral_signals.shape, (5, 100))
spots_counts = [img.compute_cytoplasmic_total_spots() for img in image_set.images]
self.assertTrue(np.all(peripheral_signals[:, 99] == np.array(spots_counts)))
self.assertAlmostEqual(peripheral_signals.sum(), 20166.0)
def test_compute_normalised_quadrant_densities_mrna(self):
image_set = ImageSet(self.repo, path_list=['mrna/arhgdia/2h/'])
res = image_set.compute_normalised_quadrant_densities()
self.assertEqual(res.shape[0], 20)
mtoc_density = res[res[:, 1] == 1].sum() / len(res[res[:, 1] == 1])
self.assertAlmostEqual(mtoc_density, 2.22758047513, places=5)
non_mtoc_density = res[res[:, 1] == 0].sum() / len(res[res[:, 1] == 0])
self.assertAlmostEqual(non_mtoc_density, 1.089256691215, places=5)
def test_compute_intensities_signal_from_periphery(self):
image_set = ImageSet(self.repo, path_list=['protein/arhgdia/4h/'])
self.assertEqual(len(image_set.images), 5, "Expected 5 images")
peripheral_signals = image_set.compute_signal_from_periphery()
cytoplasmic_intensities = [img.compute_cytoplasmic_total_intensity() for img in image_set.images]
self.assertEqual(peripheral_signals.shape, (5, 100))
self.assertTrue(np.allclose(peripheral_signals[:, 99], np.array(cytoplasmic_intensities)))
self.assertAlmostEqual(peripheral_signals.sum(), 29384734352.0)
def test_compute_areas_from_periphery(self):
image_set = ImageSet(self.repo, path_list=['mrna/arhgdia/3h/'])
self.assertEqual(len(image_set.images), 5, "Expected 5 images")
peripheral_areas = image_set.compute_areas_from_periphery()
self.assertEqual(peripheral_areas.shape, (5, 100))
cytoplasmic_areas = [img.compute_cell_area() - img.compute_nucleus_area() for img in image_set.images]
self.assertTrue(np.allclose(peripheral_areas[:, 99], np.array(cytoplasmic_areas)))
self.assertAlmostEqual(peripheral_areas.sum(), 142574.96909927676, places=5)
def compute_zline_distance(repo, molecule_list, timepoints, z_line_spacing):
all_median_profiles = []
for molecule in molecule_list:
for timepoint in timepoints:
image_set = ImageSet(repo, [f"{'mrna'}/{molecule}/{timepoint}/"])
if image_set.__sizeof__() < 5:
logger.warning("Image set is small for {}", molecule)
total_profile = image_set.compute_zline_distance(z_line_spacing)
all_median_profiles.append(np.median(total_profile, axis=0))
return all_median_profiles
def test_alignment(self):
"""
Tests if the ImageSet info is correct except the image, as this is a little unpredictable
"""
rand_im = (np.random.rand(225, 225, 4) * 255).astype(np.uint8)
rand_im[:, :, -1] = 1
input_im = np.zeros((4,) + rand_im.shape, dtype=np.uint8)
for i in range(0, input_im.shape[0]):
input_im[i] = rand_im
input_im[1, :-2, :] = input_im[1, 2:, :]
input_im[1, -3:, :] = 0
input_im[3] = np.rot90(input_im[3])
input_im_set = ImageSet(input_im)
input_im_set.original_shape = input_im.shape[1:]
input_im_set.shutter_speed = np.array([1, 2, 3, 4])
expected_im_set = ImageSet(input_im) # ignoring the returned image here
expected_im_set.original_shape = (222, 222, 4)
expected_im_set.shutter_speed = input_im_set.shutter_speed.copy()
output_image_set = input_im_set.aligned_image_set()
self.assertEqual(expected_im_set.original_shape, output_image_set.original_shape)
self.assertTrue(np.array_equal(expected_im_set.shutter_speed, output_image_set.shutter_speed))
def test_compute_cell_mask_between_nucleus_centroids(self):
image_set = ImageSet(self.repo, path_list=['mrna/actn2/immature/'])
nuc_dist, nucs_dist, cell_masks, nucs_pos = image_set.compute_cell_mask_between_nucleus_centroids()
self.assertEqual(np.sum([754, 483, 526]), np.sum(nuc_dist))
self.assertEqual(len([754]) + len([483, 526]), len(nucs_dist[0]) + len(nucs_dist[1]))
for nuc_pos in nucs_pos:
if len(nuc_pos) == 1:
self.assertEqual(nuc_pos[0],[110, 864])
else:
self.assertEqual(nuc_pos[0], [154, 637])
self.assertEqual(nuc_pos[1], [637, 1163])
def test_compute_zline_distance(self):
image_set = ImageSet(self.repo, path_list=['mrna/actn2/immature/'])
result = image_set.compute_zline_distance(20)
test = [[0.24374599, 0.03463759, 0.0365619, 0.0436177, 0.03207184,
0.02758178, 0.0365619, 0.03207184, 0.03014753, 0.02694035,
0.02309173, 0.01860167, 0.02180885, 0.02758178, 0.01988454,
0.0, 0.0, 0.0, 0.0, 0.0],
[0.38974359, 0.01230769, 0.01025641, 0.02871795, 0.02153846,
0.02461538, 0.01948718, 0.02666667, 0.03076923, 0.01333333,
0.0225641, 0.01025641, 0.01538462, 0.01333333, 0.00923077,
0.0, 0.0, 0.0, 0.0, 0.0]]
self.assertEqual(len(result), len(test))
self.assertAlmostEqual(np.sum(result), np.sum(test), places=5)
def test_gray_images(self):
"""
Tests ImageSet.gray_images()
"""
image = np.array([[[ # One image with shape (1, 3, 3)
[1, 2, 3], [2, 3, 4], [100, 100, 100]
]]])
image_set = ImageSet(image)
image_set.original_shape = (1, 3, 3)
image_set.shutter_speed = [1]
expected_image = np.array([[ # Shape (1, 3)
2, 3, 100
]]).astype(float)
output = image_set.gray_images()
self.assertTrue(np.array_equal(output.images[0], expected_image))
def test_find_reference_points_for(self):
"""
Tests the find_reference_points_for(...)
"""
gray_input = ImageSet(np.zeros(
(10, 10, 3))) # 10 images with shape (10, 3)
gray_expected = np.arange(0, 30)
gray_output = hdr.find_reference_points_for(gray_input)
self.assertTrue(np.array_equal(gray_output, gray_expected))
color_input = ImageSet(np.zeros(
(10, 1000, 300, 3))) # 10 images with shape (1000, 300, 3)
color_expected = np.arange(0, 300000, 300)
color_output = hdr.find_reference_points_for(color_input)
self.assertTrue(np.array_equal(color_output, color_expected))
def main():
image_set = ImageSet.load(sys.argv[1], 240, 320)
image_set.split(train_rate=0.9, seed="numazu_shine")
model = resnet.ResnetBuilder.build_resnet_18(
(image_set.color, image_set.height, image_set.width),
image_set.num_classes)
model.summary()
bot = LearningBot(model)
history = {}
for image_data in image_set.get_iter_for_learning_curve(5):
size = len(image_data[0])
datagen = image.ImageDataGenerator(zca_whitening=True,
rotation_range=10,
width_shift_range=0.2,
height_shift_range=0.2,
shear_range=0.5,
zoom_range=0.3,
channel_shift_range=0.,
horizontal_flip=True)
datagen.fit(image_data[0])
history[size] = bot.learn_by_generator(*image_data,
datagen,
batch_size=128,
steps_per_epoch=size / 128)
bot.draw_history_list('test.png',
history, ["acc", "val_acc"],
method=DrawMethod.best)
def test_can_build_mono_type_if(self):
image_set = ImageSet(self.repo, path_list=['protein/arhgdia/3h/'])
self.assertEqual(len(image_set.images), 5, "Expected 5 images")
for image in image_set.images:
self.assertTrue(type(image) == Image3dWithIntensitiesAndMTOC)
with self.assertRaises(AttributeError): # 'ImageWithIntensities' object has no attribute 'get_spots'
self.assertEqual(image.get_spots().shape[1], 3)
self.assertEqual(image.get_intensities().shape, (512, 512))
def intensities_cytoplasmic_total_count(analysis_repo, keyorder):
gene2cyto_count = {}
gene2median_cyto_count = {}
gene2error = {}
gene2confidence_interval = {}
for gene in constants.analysis_config['PROTEINS']:
logger.info("Running protein cytoplasmic total count analysis for {}", gene)
imageset = ImageSet(analysis_repo, ['protein/%s/' % gene])
gene2cyto_count[gene] = imageset.compute_cytoplasmic_intensities()
gene2median_cyto_count[gene] = np.median(gene2cyto_count[gene])
gene2error[gene] = helpers.sem(gene2cyto_count[gene], factor=0)
lower, higher = helpers.median_confidence_interval(gene2cyto_count[gene])
gene2confidence_interval[gene] = [lower, higher]
# generate bar plot image
gene2median_cyto_count = collections.OrderedDict(sorted(gene2median_cyto_count.items(), key=lambda i: keyorder.index(i[0])))
gene2error = collections.OrderedDict(sorted(gene2error.items(), key=lambda i: keyorder.index(i[0])))
gene2confidence_interval = collections.OrderedDict(sorted(gene2confidence_interval.items(), key=lambda i: keyorder.index(i[0])))
xlabels = constants.analysis_config['PROTEINS_LABEL']
tgt_image_name = constants.analysis_config['FIGURE_NAME_FORMAT'].format(molecule_type="protein")
tgt_fp = pathlib.Path(constants.analysis_config['FIGURE_OUTPUT_PATH'].format(root_dir=global_root_dir),
tgt_image_name)
plot.bar_profile_median(gene2median_cyto_count,
gene2error.values(),
'proteins',
xlabels,
tgt_fp,
gene2confidence_interval,
annot=False,
data_to_annot=gene2cyto_count
)
# generate violin plot image
tgt_image_name = constants.analysis_config['FIGURE_NAME_VIOLIN_FORMAT'].format(molecule_type="protein")
tgt_fp = pathlib.Path(constants.analysis_config['FIGURE_OUTPUT_PATH'].format(root_dir=global_root_dir),
tgt_image_name)
plot.violin_profile(gene2cyto_count, tgt_fp, xlabels, rotation=0, annot=True)
def __init__(self):
super().__init__()
self.title = 'Stimat'
self.main_image = PlotCanvas(width=5, height=4)
self.original_image_set = ImageSet([])
self.edited_image = None
self.hdr_image = None
self.filter_widgets = list()
self.filter_layout = QVBoxLayout()
self.add_global_filter_button = QPushButton("Legg til globalt filter",
self)
self.add_lum_filter_button = QPushButton("Legg til luminans filter",
self)
self.add_gaussian_button = QPushButton("Legg til gaussian filter",
self)
self.add_bilateral_button = QPushButton("Legg til bilateral filter",
self)
self.add_gradient_compression_button = QPushButton(
"Legg til gradient comp. filter", self)
self.save_image_button = QPushButton("Lagre bilde", self)
self.align_image_button = QPushButton("Opplinjer Bildesett", self)
self.status_label = QLabel("Ingen bilder er lastet inn")
self.init_ui()
def compute_relative_densities(analysis_repo,
molecule_type,
quadrants_num=4,
peripheral_flag=False):
densities = {}
stripes = constants.analysis_config['STRIPE_NUM']
if peripheral_flag:
stripes_flag = False
stripes = 1
else:
stripes_flag = True
if molecule_type == 'mrna':
timepoints = constants.dataset_config['TIMEPOINTS_MRNA']
else:
timepoints = constants.dataset_config['TIMEPOINTS_PROTEIN']
for gene in constants.analysis_config['PROTEINS']:
median_densities, gene_clusters = [], []
for timepoint in timepoints:
image_set = ImageSet(
analysis_repo,
[molecule_type + "/{0}/{1}/".format(gene, timepoint)])
arr = image_set.compute_normalised_quadrant_densities(
quadrants_num=quadrants_num,
peripheral_flag=peripheral_flag,
stripes=stripes,
stripes_flag=stripes_flag)
num_images = arr.shape[0] // (quadrants_num * stripes)
aligned_densities = arr[:, 0].reshape(num_images,
quadrants_num * stripes)
median_densities_per_slice = np.nanmedian(aligned_densities,
axis=0)
median_densities.append(median_densities_per_slice)
densities[gene] = median_densities
return densities
def compute_density_per_quadrant(analysis_repo,
molecule_type,
groupby_key,
quadrants_num,
quadrant_labels,
molecule_list,
time_points,
mpi_sample_size,
peripheral_flag=False):
assert len(quadrant_labels) == quadrants_num - 1
density_per_quadrant = []
for molecule in molecule_list:
for timepoint in time_points:
density_statictics = {}
image_set = ImageSet(analysis_repo,
[f"{molecule_type}/{molecule}/{timepoint}/"])
if len(image_set.images) < 5:
logger.warning("Image set is small for {}", molecule)
res = image_set.compute_normalised_quadrant_densities(
quadrants_num=quadrants_num, peripheral_flag=peripheral_flag)
mtoc_quadrants = res[res[:, 1] == 1][:, 0]
num_images = res.shape[0] // quadrants_num
non_mtoc_quadrants = res[res[:, 1] == 0][:, 0].reshape(
num_images, quadrants_num - 1)
density_statictics["Gene"] = [molecule] * num_images
density_statictics["Timepoint"] = [timepoint] * num_images
density_statictics["MTOC"] = mtoc_quadrants
for i in range(0, quadrants_num - 1):
density_statictics["Non MTOC" + str(i)] = non_mtoc_quadrants[:,
i]
density_per_quadrant.append(pd.DataFrame(density_statictics))
return DensityStats(df=pd.concat(density_per_quadrant),
group_key=groupby_key,
mpi_sample_size=mpi_sample_size,
quadrant_labels=quadrant_labels,
mtoc_quadrant_label='MTOC')
def select_file(self):
"""
Selects a set of files and generates a HDR image
"""
file_name, ok = QFileDialog.getOpenFileNames(
self, "Velg bilde", "", "PNG (*.png);;EXR (*.exr)")
if ok:
self.add_global_filter_button.setEnabled(True)
self.add_lum_filter_button.setEnabled(True)
self.add_gaussian_button.setEnabled(True)
self.add_bilateral_button.setEnabled(True)
self.add_gradient_compression_button.setEnabled(True)
self.save_image_button.setEnabled(True)
try:
if file_name[0].endswith(".exr"):
self.original_image_set = None
self.hdr_image = read_image(file_name[0])
self.align_image_button.setEnabled(False)
else:
image_info = list(
map(
lambda file: (file, file.rsplit("_", 1)[-1].
replace(".png", "")), file_name))
self.original_image_set = ImageSet(image_info)
self.hdr_image = self.original_image_set.hdr_image(10)
self.align_image_button.setEnabled(True)
self.update_image_with_filter()
self.status_label.setText("Bilde ble lastet inn")
self.status_label.setStyleSheet("background: green")
except:
self.status_label.setText(
"Ups! Det skjedde en feil ved innlasting av bildet")
self.status_label.setStyleSheet("background: red")
def test_compute_cytoplasmic_spots_fractions_per_periphery(self):
image_set = ImageSet(self.repo, path_list=['mrna/arhgdia/3h/'])
peripheral_fractions = image_set.compute_cytoplasmic_spots_fractions_per_periphery()
self.assertEqual(peripheral_fractions.shape, (5, 100))
self.assertTrue(np.all(peripheral_fractions[:, 99] == 1))
self.assertAlmostEqual(peripheral_fractions.sum(), 719.995179047, places=5)
image_set = ImageSet(self.repo, path_list=['mrna/arhgdia/4h/'], force2D=True)
peripheral_fractions = image_set.compute_cytoplasmic_spots_fractions_per_periphery(force2D=True)
self.assertEqual(peripheral_fractions.shape, (5, 100))
self.assertTrue(np.all(peripheral_fractions[:, 99] == 1))
def build_cytoplasmic_statistics(analysis_repo, statistics_type, molecule_type,
genes, keyorder):
gene2stat, gene2median, gene2error, gene2confidence_interval = {}, {}, {}, {}
for gene in genes:
logger.info("Running {} cytoplasmic {} analysis for {}", molecule_type,
statistics_type, gene)
image_set = ImageSet(analysis_repo,
['{0}/{1}/'.format(molecule_type, gene)])
if statistics_type == 'centrality':
if molecule_type == 'mrna':
gene2stat[
gene] = image_set.compute_cytoplasmic_spots_centrality()
else:
gene2stat[
gene] = image_set.compute_cytoplasmic_intensities_centrality(
)
if statistics_type == 'spread':
if molecule_type == 'mrna':
gene2stat[gene] = image_set.compute_cytoplasmic_spots_spread()
else:
gene2stat[
gene] = image_set.compute_intensities_cytoplasmic_spread()
if statistics_type == 'centrality':
gene2median[gene] = np.mean(gene2stat[gene])
gene2error[gene] = helpers.sem(gene2stat[gene], factor=0)
lower, higher = helpers.median_confidence_interval(gene2stat[gene])
gene2confidence_interval[gene] = [lower, higher]
if statistics_type == 'spread':
max_entropy = np.max([np.max(gene2stat[k]) for k in gene2stat.keys()])
for gene in gene2stat.keys():
gene2stat[gene] = gene2stat[gene] / max_entropy
gene2median[gene] = np.median(gene2stat[gene])
gene2error[gene] = helpers.sem(gene2stat[gene], factor=0)
lower, higher = helpers.median_confidence_interval(gene2stat[gene])
gene2confidence_interval[gene] = [lower, higher]
gene2stat = collections.OrderedDict(
sorted(gene2stat.items(), key=lambda i: keyorder.index(i[0])))
gene2median = collections.OrderedDict(
sorted(gene2median.items(), key=lambda i: keyorder.index(i[0])))
gene2error = collections.OrderedDict(
sorted(gene2error.items(), key=lambda i: keyorder.index(i[0])))
gene2confidence_interval = collections.OrderedDict(
sorted(gene2confidence_interval.items(),
key=lambda i: keyorder.index(i[0])))
return gene2median, gene2stat, gene2error, gene2confidence_interval
def test_compute_normalized_quadrant_densities_mrna(self):
image_set = ImageSet(self.repo, path_list=['mrna/arhgdia/2h/'])
result1 = image_set.compute_normalised_quadrant_densities(quadrants_num=8)
num_images = image_set.__sizeof__()
self.assertEqual(num_images, image_set.__sizeof__())
self.assertAlmostEqual(result1[result1[:, 1] == 1][:, 0].sum() / num_images,
1.0780173273, places=5) # MTOC quadrant density
self.assertAlmostEqual(result1[result1[:, 1] == 0][:, 0].sum() / (num_images * 7),
1.1263246459, places=5) # non MTOC quadrant density
result2 = image_set.compute_normalised_quadrant_densities(quadrants_num=8, stripes=3, stripes_flag=True)
self.assertAlmostEqual(result2[result2[:, 1] == 1][:, 0].sum() / (3 * num_images),
1.0225376792, places=5) # MTOC quadrant density
self.assertAlmostEqual(result2[result2[:, 1] == 0][:, 0].sum() / (num_images * 7 * 3),
1.08160649427, places=5) # non MTOC quadrant density
result3 = image_set.compute_normalised_quadrant_densities(quadrants_num=8, peripheral_flag=True,
stripes=3, stripes_flag=True)
self.assertAlmostEqual(result3[result3[:, 1] == 1][:, 0].sum() / (3 * num_images),
0.79154809935, places=5) # MTOC quadrant density
self.assertAlmostEqual(result3[result3[:, 1] == 0][:, 0].sum() / (num_images * 7 * 3),
0.59408432134, places=5) # non MTOC quadrant density
def test_compute_normalized_quadrant_densities_protein(self):
image_set = ImageSet(self.repo, path_list=['protein/arhgdia/3h/'])
result1 = image_set.compute_normalised_quadrant_densities(quadrants_num=8)
num_images = image_set.__sizeof__()
self.assertEqual(num_images, image_set.__sizeof__())
self.assertAlmostEqual(result1[result1[:, 1] == 1][:, 0].sum() / num_images,
1.098770606, places=5) # MTOC quadrant density
self.assertAlmostEqual(result1[result1[:, 1] == 0][:, 0].sum() / (num_images * 7),
0.865466580, places=5) # non MTOC quadtant density
result2 = image_set.compute_normalised_quadrant_densities(quadrants_num=8, stripes=3, stripes_flag=True)
self.assertAlmostEqual(result2[result2[:, 1] == 1][:, 0].sum() / (3 * num_images),
0.9803183396, places=5) # MTOC quadrant density
self.assertAlmostEqual(result2[result2[:, 1] == 0][:, 0].sum() / (num_images * 7 * 3),
0.6801687989, places=5) # non MTOC quadtant density
result3 = image_set.compute_normalised_quadrant_densities(quadrants_num=8, peripheral_flag=True,
stripes=3, stripes_flag=True)
self.assertAlmostEqual(result3[result3[:, 1] == 1][:, 0].sum() / (3 * num_images),
0.126123087, places=5) # MTOC quadrant density
self.assertAlmostEqual(result3[result3[:, 1] == 0][:, 0].sum() / (num_images * 7 * 3),
0.011356787, places=5) # non MTOC quadtant density
def compute_nuclei_area(gene, analysis_repo, gene_label, timepoint):
dict_nucleus_area = {"Gene": [], "value": []}
image_set = ImageSet(analysis_repo, [f"{'mrna'}/{gene}/{timepoint}/"])
[dict_nucleus_area["value"].append(image.compute_nucleus_area()) for image in image_set.get_images()]
[dict_nucleus_area["Gene"].append(gene_label) for image in image_set.get_images()]
return pd.DataFrame(dict_nucleus_area)
