Beispiel #1
0
 def test_IlluminationGradient(self):
     illumination_gradient = optics.IlluminationGradient(gradient=(5e-5,
                                                                   5e-5))
     microscope = optics.Brightfield(
         NA=0.7,
         wavelength=660e-9,
         resolution=1e-6,
         magnification=10,
         refractive_index_medium=1.33,
         upscale=2,
         output_region=(0, 0, 64, 64),
         padding=(10, 10, 10, 10),
         aberration=None,
         illumination=illumination_gradient,
     )
     scatterer = PointParticle(
         refractive_index=1.45 + 0.1j,
         position_unit="pixel",
         position=(32, 32),
     )
     imaged_scatterer = microscope(scatterer)
     output_image = imaged_scatterer.resolve()
     self.assertIsInstance(output_image, Image)
     self.assertEqual(output_image.shape, (64, 64, 1))
     self.assertEqual(
         output_image.get_property("pupil_at_focus").shape, (128, 128))
Beispiel #2
0
    def test_Generator(self):
        optics = Fluorescence(
            NA=0.7,
            wavelength=680e-9,
            resolution=1e-6,
            magnification=10,
            output_region=(0, 0, 128, 128),
        )
        scatterer = PointParticle(
            intensity=100,
            position_unit="pixel",
            position=lambda: np.random.rand(2) * 128,
        )
        imaged_scatterer = optics(scatterer)

        def get_particle_position(result):
            for property in result.properties:
                if "position" in property:
                    return property["position"]

        generator = generators.Generator()
        particle_generator = generator.generate(imaged_scatterer,
                                                get_particle_position,
                                                batch_size=4)
        particles, positions = next(particle_generator)
        for particle, position in zip(particles, positions):
            self.assertEqual(particle.shape, (128, 128, 1))
            self.assertTrue(np.all(position >= 0))
            self.assertTrue(np.all(position <= 128))
Beispiel #3
0
 def test_Brightfield(self):
     microscope = optics.Brightfield(NA=0.7,
                                     wavelength=660e-9,
                                     resolution=1e-6,
                                     magnification=10,
                                     refractive_index_medium=1.33,
                                     upscale=2,
                                     output_region=(0, 0, 64, 64),
                                     padding=(10, 10, 10, 10),
                                     aberration=None)
     scatterer = PointParticle(
         refractive_index=1.45 + 0.1j,
         position_unit="pixel",
         position=(32, 32),
     )
     imaged_scatterer = microscope(scatterer)
     output_image = imaged_scatterer.resolve()
     self.assertIsInstance(output_image, Image)
     self.assertEqual(output_image.shape, (64, 64, 1))
Beispiel #4
0
 def test_Fluorescence(self):
     microscope = optics.Fluorescence(NA=0.7,
                                      wavelength=660e-9,
                                      resolution=1e-6,
                                      magnification=10,
                                      refractive_index_medium=1.33,
                                      upscale=2,
                                      padding=(10, 10, 10, 10),
                                      output_region=(0, 0, 64, 64),
                                      aberration=None)
     scatterer = PointParticle(
         intensity=100,  # Squared magnitude of the field. 
         position_unit="pixel",  # Units of position (default meter)
         position=(32, 32),  # Position of the particle
     )
     imaged_scatterer = microscope(scatterer)
     output_image = imaged_scatterer.resolve()
     self.assertIsInstance(output_image, Image)
     self.assertEqual(output_image.shape, (64, 64, 1))
Beispiel #5
0
class TestAberrations(unittest.TestCase):

    particle = PointParticle(position=(32, 32), position_unit="pixel", intensity=1)

    def testGaussianApodization(self):
        aberrated_optics = Fluorescence(
            NA=0.3,
            resolution=1e-6,
            magnification=10,
            wavelength=530e-9,
            output_region=(0, 0, 64, 64),
            padding=(64, 64, 64, 64),
            aberration=aberrations.GaussianApodization(sigma=0.5),
        )
        aberrated_particle = aberrated_optics(self.particle)
        for z in (-100, 0, 100):
            im = aberrated_particle.resolve(z=z)
            self.assertIsInstance(im, Image)
            self.assertEqual(im.shape, (64, 64, 1))

    def testPiston(self):
        aberrated_optics = Fluorescence(
            NA=0.3,
            resolution=1e-6,
            magnification=10,
            wavelength=530e-9,
            output_region=(0, 0, 64, 64),
            padding=(64, 64, 64, 64),
            aberration=aberrations.Piston(coefficient=1),
        )
        aberrated_particle = aberrated_optics(self.particle)
        for z in (-100, 0, 100):
            im = aberrated_particle.resolve(z=z)
            self.assertIsInstance(im, Image)
            self.assertEqual(im.shape, (64, 64, 1))

    def testVerticalTilt(self):
        aberrated_optics = Fluorescence(
            NA=0.3,
            resolution=1e-6,
            magnification=10,
            wavelength=530e-9,
            output_region=(0, 0, 64, 64),
            padding=(64, 64, 64, 64),
            aberration=aberrations.VerticalTilt(coefficient=1),
        )
        aberrated_particle = aberrated_optics(self.particle)
        for z in (-100, 0, 100):
            im = aberrated_particle.resolve(z=z)
            self.assertIsInstance(im, Image)
            self.assertEqual(im.shape, (64, 64, 1))

    def testHorizontalTilt(self):
        aberrated_optics = Fluorescence(
            NA=0.3,
            resolution=1e-6,
            magnification=10,
            wavelength=530e-9,
            output_region=(0, 0, 64, 64),
            padding=(64, 64, 64, 64),
            aberration=aberrations.HorizontalTilt(coefficient=1),
        )
        aberrated_particle = aberrated_optics(self.particle)
        for z in (-100, 0, 100):
            im = aberrated_particle.resolve(z=z)
            self.assertIsInstance(im, Image)
            self.assertEqual(im.shape, (64, 64, 1))

    def testObliqueAstigmatism(self):
        aberrated_optics = Fluorescence(
            NA=0.3,
            resolution=1e-6,
            magnification=10,
            wavelength=530e-9,
            output_region=(0, 0, 64, 64),
            padding=(64, 64, 64, 64),
            aberration=aberrations.ObliqueAstigmatism(coefficient=1),
        )
        aberrated_particle = aberrated_optics(self.particle)
        for z in (-100, 0, 100):
            im = aberrated_particle.resolve(z=z)
            self.assertIsInstance(im, Image)
            self.assertEqual(im.shape, (64, 64, 1))

    def testDefocus(self):
        aberrated_optics = Fluorescence(
            NA=0.3,
            resolution=1e-6,
            magnification=10,
            wavelength=530e-9,
            output_region=(0, 0, 64, 64),
            padding=(64, 64, 64, 64),
            aberration=aberrations.Defocus(coefficient=1),
        )
        aberrated_particle = aberrated_optics(self.particle)
        for z in (-100, 0, 100):
            im = aberrated_particle.resolve(z=z)
            self.assertIsInstance(im, Image)
            self.assertEqual(im.shape, (64, 64, 1))

    def testAstigmatism(self):
        aberrated_optics = Fluorescence(
            NA=0.3,
            resolution=1e-6,
            magnification=10,
            wavelength=530e-9,
            output_region=(0, 0, 64, 64),
            padding=(64, 64, 64, 64),
            aberration=aberrations.Astigmatism(coefficient=1),
        )
        aberrated_particle = aberrated_optics(self.particle)
        for z in (-100, 0, 100):
            im = aberrated_particle.resolve(z=z)
            self.assertIsInstance(im, Image)
            self.assertEqual(im.shape, (64, 64, 1))

    def testObliqueTrefoil(self):
        aberrated_optics = Fluorescence(
            NA=0.3,
            resolution=1e-6,
            magnification=10,
            wavelength=530e-9,
            output_region=(0, 0, 64, 64),
            padding=(64, 64, 64, 64),
            aberration=aberrations.ObliqueTrefoil(coefficient=1),
        )
        aberrated_particle = aberrated_optics(self.particle)
        for z in (-100, 0, 100):
            im = aberrated_particle.resolve(z=z)
            self.assertIsInstance(im, Image)
            self.assertEqual(im.shape, (64, 64, 1))

    def testVerticalComa(self):
        aberrated_optics = Fluorescence(
            NA=0.3,
            resolution=1e-6,
            magnification=10,
            wavelength=530e-9,
            output_region=(0, 0, 64, 64),
            padding=(64, 64, 64, 64),
            aberration=aberrations.VerticalComa(coefficient=1),
        )
        aberrated_particle = aberrated_optics(self.particle)
        for z in (-100, 0, 100):
            im = aberrated_particle.resolve(z=z)
            self.assertIsInstance(im, Image)
            self.assertEqual(im.shape, (64, 64, 1))

    def testHorizontalComa(self):
        aberrated_optics = Fluorescence(
            NA=0.3,
            resolution=1e-6,
            magnification=10,
            wavelength=530e-9,
            output_region=(0, 0, 64, 64),
            padding=(64, 64, 64, 64),
            aberration=aberrations.HorizontalComa(coefficient=1),
        )
        aberrated_particle = aberrated_optics(self.particle)
        for z in (-100, 0, 100):
            im = aberrated_particle.resolve(z=z)
            self.assertIsInstance(im, Image)
            self.assertEqual(im.shape, (64, 64, 1))

    def testTrefoil(self):
        aberrated_optics = Fluorescence(
            NA=0.3,
            resolution=1e-6,
            magnification=10,
            wavelength=530e-9,
            output_region=(0, 0, 64, 64),
            padding=(64, 64, 64, 64),
            aberration=aberrations.Trefoil(coefficient=1),
        )
        aberrated_particle = aberrated_optics(self.particle)
        for z in (-100, 0, 100):
            im = aberrated_particle.resolve(z=z)
            self.assertIsInstance(im, Image)
            self.assertEqual(im.shape, (64, 64, 1))

    def testSphericalAberration(self):
        aberrated_optics = Fluorescence(
            NA=0.3,
            resolution=1e-6,
            magnification=10,
            wavelength=530e-9,
            output_region=(0, 0, 64, 64),
            padding=(64, 64, 64, 64),
            aberration=aberrations.SphericalAberration(coefficient=1),
        )
        aberrated_particle = aberrated_optics(self.particle)
        for z in (-100, 0, 100):
            im = aberrated_particle.resolve(z=z)
            self.assertIsInstance(im, Image)
            self.assertEqual(im.shape, (64, 64, 1))