Ejemplo n.º 1
0
 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)
Ejemplo n.º 2
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)
Ejemplo n.º 3
0
 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
Ejemplo n.º 4
0
 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
Ejemplo n.º 5
0
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
Ejemplo n.º 6
0
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')