def test_pullingoutguess(): g = Sphere(center=(par(guess=.567e-5, limit=[0, 1e-5]), par(.567e-5, (0, 1e-5)), par(15e-6, (1e-5, 2e-5))), r=par(8.5e-7, (1e-8, 1e-5)), n=ComplexParameter(par(1.59, (1, 2)), 1e-4)) model = Model(g, Mie.calc_holo) s = Sphere(center=[.567e-5, .567e-5, 15e-6], n=1.59 + 1e-4j, r=8.5e-7) assert_equal(s.n, model.scatterer.guess.n) assert_equal(s.r, model.scatterer.guess.r) assert_equal(s.center, model.scatterer.guess.center) g = Sphere(center=(par(guess=.567e-5, limit=[0, 1e-5]), par(.567e-5, (0, 1e-5)), par(15e-6, (1e-5, 2e-5))), r=par(8.5e-7, (1e-8, 1e-5)), n=1.59 + 1e-4j) model = Model(g, Mie.calc_holo) s = Sphere(center=[.567e-5, .567e-5, 15e-6], n=1.59 + 1e-4j, r=8.5e-7) assert_equal(s.n, model.scatterer.guess.n) assert_equal(s.r, model.scatterer.guess.r) assert_equal(s.center, model.scatterer.guess.center)
def test_next_model(): exampleresult = FitResult(parameters={ 'center[1]': 31.367170884695756, 'r': 0.6465280831465722, 'center[0]': 32.24150087110443, 'center[2]': 35.1651561654966, 'alpha': 0.7176299231169572, 'n': 1.580122175314896}, scatterer=Sphere(n=1.580122175314896, r=0.6465280831465722, center=[32.24150087110443, 31.367170884695756, 35.1651561654966]), chisq=0.0001810513851216454, rsq=0.9727020197282801, converged=True, time=5.179728031158447, model=Model(scatterer=ParameterizedObject(obj= Sphere(n=Parameter(guess=1.59, limit=[1.4, 1.7], name='n'), r=Parameter(guess=0.65, limit=[0.6, 0.7], name='r'), center=[Parameter(guess=32.110424836601304, limit=[2, 40], name='center[0]'), Parameter(guess=31.56683986928105, limit=[4, 40], name='center[1]'), Parameter(guess=33, limit=[5, 45], name='center[2]')])), theory=Mie.calc_holo, alpha=Parameter(guess=0.6, limit=[0.1, 1], name='alpha'), constraints=[]), minimizer = None, minimization_details = None) gold = Model(scatterer=ParameterizedObject(obj=Sphere( n=Parameter(guess=1.580122175314896, limit=[1.4, 1.7], name='n'), r=Parameter(guess=0.6465280831465722, limit=[0.6, 0.7], name='r'), center=[Parameter(guess=32.24150087110443, limit=[2, 40], name='center[0]'), Parameter(guess=31.367170884695756, limit=[4, 40], name='center[1]'), Parameter(guess=35.1651561654966, limit=[5, 45], name='center[2]')])), theory=Mie.calc_holo, alpha=Parameter(guess=0.7176299231169572, limit=[0.1, 1], name='alpha'), constraints=[]) assert_obj_close(gold, exampleresult.next_model())
def calculateHologram(self): #calculate hologram with current settings self.warning.setText('Calculating...') #self.compute.setChecked(True) scale = self.scale sender = self.sender() ######## hologram calculation (4x big to allow scrolling) start = time.time() sphere = Sphere(n = self.lcd5.value()+.0001j, r = self.lcd4.value(), center = (256*self.scale,256*self.scale,self.lcd3.value())) sphere2 = Sphere(n = self.lcd5.value()+.0001j, r = self.lcd4.value(), center = (self.lcd.value(),self.lcd2.value(),self.lcd3.value())) self.sphObject.setText(repr(sphere2)) schema = ImageSchema(shape = 512, spacing = float(self.pxsizeText.text()), optics = Optics(wavelen = float(self.waveText.text()), index = float(self.mindexText.text()), polarization = [1,0])) schema2 = ImageSchema(shape = 256, spacing = float(self.pxsizeText.text()), optics = Optics(wavelen = float(self.waveText.text()), index = float(self.mindexText.text()), polarization = [1,0])) self.schemaObject.setText(str(repr(schema2))) self.holo = Mie.calc_holo(sphere, schema) self.lastholo = self.holo self.lastZ = self.lcd3.value() end = time.time() #now take only the part that you want to display x = round(self.sld.value()) y = round(self.sld2.value()) im = toimage(self.holo[256-x:512-x,256-y:512-y]) #PIL image #https://github.com/shuge/Enjoy-Qt-Python-Binding/blob/master/image/display_img/pil_to_qpixmap.py #myQtImage = ImageQt(im) #qimage = QtGui.QImage(myQtImage) if im.mode == "RGB": pass elif im.mode == "L": im = im.convert("RGBA") data = im.tostring('raw',"RGBA") qim = QtGui.QImage(data, 256, 256, QtGui.QImage.Format_ARGB32) pixmap = QtGui.QPixmap.fromImage(qim) myScaledPixmap = pixmap.scaled(QtCore.QSize(400,400)) self.warning.setText('') self.hologram.setPixmap(myScaledPixmap) #self.hologram.setScaledContents(True) #myScaledPixmap.scaledToWidth(True) self.timer.setText('Calc. Time: '+str(round(end-start,4))+' s') self.timer.setAlignment(QtCore.Qt.AlignBottom | QtCore.Qt.AlignCenter)
def test_scattering_matrix_pathway_returns_linear_in_scatmatrs(self): theory = MockScatteringMatrixBasedTheory() sphere01 = Sphere(n=1.5, r=1.0, center=(0, 0, 2)) sphere02 = Sphere(n=1.5, r=2.0, center=(0, 0, 2)) fields01 = theory.calculate_scattered_field(sphere01, XSCHEMA) fields02 = theory.calculate_scattered_field(sphere02, XSCHEMA) self.assertTrue( np.allclose(fields02.values, 2 * fields01.values, **TOLS))
def test_DDA_indicator(): n = 1.59 center = (1, 1, 30) r = .3 sc = Sphere(n=n, r=r, center = center) sphere_holo = calc_holo(schema, sc, index, wavelen, theory=DDA) s = Scatterer(Sphere(r=r, center = (0, 0, 0)).contains, n, center) gen_holo = calc_holo(schema, s, index, wavelen, theory=DDA) assert_allclose(sphere_holo, gen_holo, rtol=2e-3)
def test_Spheres_construction_typechecking(): # heterogeneous composite should raise exception, since a # sphere cluster must contain only Spheres s1 = Sphere(n = 1.59, r = 5e-7, center = (1e-6, -1e-6, 10e-6)) s2 = Sphere(n = 1.59, r = 1e-6, center=[0,0,0]) s3 = Sphere(n = 1.59+0.0001j, r = 5e-7, center=[5e-6,0,0]) cs = Ellipsoid(n=1.59+0.0001j, r=(5e-7, 5e-7, 8e-7), center=[-5e-6, 0,0]) sc = Spheres(scatterers=[s1, s2, s3, cs])
def test_csg_dda(): s = Sphere(n = 1.6, r=.1, center=(5, 5, 5)) st = s.translated(.03, 0, 0) pacman = Difference(s, st) sch = detector_grid(10, .1) h = calc_holo(sch, pacman, 1.33, .66, illum_polarization=(0, 1)) verify(h, 'dda_csg') rotated_pac = pacman.rotated(np.pi/2, 0, 0) hr = calc_holo(sch, rotated_pac, 1.33, .66, illum_polarization=(0, 1)) verify(h/hr, 'dda_csg_rotated_div')
def test_csg_dda(): s = Sphere(n = 1.6, r=.1, center=(5, 5, 5)) st = s.translated(.03, 0, 0) pacman = Difference(s, st) sch = ImageSchema(10, .1, Optics(.66, 1.33, (0, 1))) h = DDA.calc_holo(pacman, sch) verify(h, 'dda_csg') hr = DDA.calc_holo(pacman.rotated(np.pi/2, 0, 0), sch) rotated_pac = pacman.rotated(np.pi/2, 0, 0) verify(h/hr, 'dda_csg_rotated_div')
def test_fit_superposition(): """ Fit Mie superposition to a calculated hologram from two spheres """ # Make a test hologram optics = Optics(wavelen=6.58e-07, index=1.33, polarization=[0.0, 1.0], divergence=0, spacing=None, train=None, mag=None, pixel_scale=[2 * 2.302e-07, 2 * 2.302e-07]) s1 = Sphere(n=1.5891 + 1e-4j, r=.65e-6, center=(1.56e-05, 1.44e-05, 15e-6)) s2 = Sphere(n=1.5891 + 1e-4j, r=.65e-6, center=(3.42e-05, 3.17e-05, 10e-6)) sc = Spheres([s1, s2]) alpha = .629 theory = Mie(optics, 100) holo = theory.calc_holo(sc, alpha) # Now construct the model, and fit parameters = [ Parameter(name='x0', guess=1.6e-5, limit=[0, 1e-4]), Parameter('y0', 1.4e-5, [0, 1e-4]), Parameter('z0', 15.5e-6, [0, 1e-4]), Parameter('r0', .65e-6, [0.6e-6, 0.7e-6]), Parameter('nr', 1.5891, [1, 2]), Parameter('x1', 3.5e-5, [0, 1e-4]), Parameter('y1', 3.2e-5, [0, 1e-4]), Parameter('z1', 10.5e-6, [0, 1e-4]), Parameter('r1', .65e-6, [0.6e-6, 0.7e-6]) ] def make_scatterer(x0, x1, y0, y1, z0, z1, r0, r1, nr): s = Spheres([ Sphere(center=(x0, y0, z0), r=r0, n=nr + 1e-4j), Sphere(center=(x1, y1, z1), r=r1, n=nr + 1e-4j) ]) return s model = Model(parameters, Mie, make_scatterer=make_scatterer, alpha=Parameter('alpha', .63, [.5, 0.8])) result = fit(model, holo) assert_obj_close(result.scatterer, sc) assert_approx_equal(result.alpha, alpha, significant=4) assert_equal(result.model, model) assert_read_matches_write(result)
def test_Spheres_translation(): s1 = Sphere(n = 1.59, r = 5, center=[1, -1, 10]) s2 = Sphere(n = 1.59, r = 1, center=[0,0,0]) sc = Spheres(scatterers = [s1, s2]) sc2 = sc.translated(1, 1, 1) assert_equal(sc.scatterers[0].r, sc2.scatterers[0].r) assert_equal(sc.scatterers[1].r, sc2.scatterers[1].r) assert_equal(sc.scatterers[0].n, sc2.scatterers[0].n) assert_equal(sc.scatterers[1].n, sc2.scatterers[1].n) assert_equal([2, 0, 11], sc2.scatterers[0].center) assert_equal([1, 1, 1], sc2.scatterers[1].center)
def test_Spheres_rotation(): s1 = Sphere(n = 1.59, r = 1, center = [1, 0, 0]) s2 = Sphere(n = 1.59, r = 1, center = [-1, 0, 1]) sc = Spheres(scatterers = [s1, s2]) sc2 = sc.rotated(-np.pi/2, 0, 0) assert_equal(sc.scatterers[0].r, sc2.scatterers[0].r) assert_equal(sc.scatterers[1].r, sc2.scatterers[1].r) assert_equal(sc.scatterers[0].n, sc2.scatterers[0].n) assert_equal(sc.scatterers[1].n, sc2.scatterers[1].n) assert_almost_equal([0, -1, 0], sc2.scatterers[0].center) assert_almost_equal([0, 1, 1], sc2.scatterers[1].center)
def test_integer_correctness(): # we keep having bugs where the fitter doesn't schema = ImageSchema(shape = 100, spacing = .1, optics = Optics(wavelen = .660, index = 1.33, polarization = (1, 0))) s = Sphere(center = (10.2, 9.8, 10.3), r = .5, n = 1.58) holo = Mie.calc_holo(s, schema) par_s = Sphere(center = (par(guess = 10, limit = [5,15]), par(10, [5, 15]), par(10, [5, 15])), r = .5, n = 1.58) model = Model(par_s, Mie.calc_holo, alpha = par(.6, [.1, 1])) result = fit(model, holo) assert_allclose(result.scatterer.center, [10.2, 9.8, 10.3])
def test_constraint(): sch = ImageSchema(100) with warnings.catch_warnings(): # TODO: we should really only supress overlap warnings here, # but I am too lazy to figure it out right now, and I don't # think we are likely to hit warnings here that won't get # caught elsewhere -tgd 2013-12-01 warnings.simplefilter("ignore") spheres = Spheres([Sphere(r=.5, center=(0,0,0)), Sphere(r=.5, center=(0,0,par(.2)))]) model = Model(spheres, Multisphere.calc_holo, constraints=limit_overlaps()) coster = CostComputer(sch, model) cost = coster._calc({'1:Sphere.center[2]' : .2}) assert_equal(cost, np.ones_like(sch)*np.inf)
def test_mielens_multiple_returns_nonzero(self): scatterers = [ Sphere(n=1.59, r=5e-7, center=(1e-6, -1e-6, 10e-6)), Sphere(n=1.59, r=1e-6, center=[8e-6, 5e-6, 5e-6]), Sphere(n=1.59 + 0.0001j, r=5e-7, center=[5e-6, 10e-6, 3e-6]), ] sphere_collection = Spheres(scatterers=scatterers) theory = MieLens() schema = yschema holo = calc_holo(schema, sphere_collection, index, wavelen, theory=theory) self.assertTrue(holo is not None) self.assertTrue(holo.values.std() > 0)
def slide(self, value): ''' When x or y are changed, instead of recomputing the hologram, we use the shortcut of selection a region of a larger pre-computed hologram. ''' source = self.sender() #select area to display x = round(self.lcd.value() / self.scale) y = round(self.lcd2.value() / self.scale) im = scipy.misc.toimage(self.holo[256 - x:512 - x, 256 - y:512 - y]) #PIL image #convert image to pixmap #https://github.com/shuge/Enjoy-Qt-Python-Binding/blob/master/image/display_img/pil_to_qpixmap.py if im.mode == "RGB": pass elif im.mode == "L": im = im.convert("RGBA") data = im.tostring('raw', "RGBA") qim = QtGui.QImage(data, 256, 256, QtGui.QImage.Format_ARGB32) pixmap = QtGui.QPixmap.fromImage(qim) #asign to the hologram myScaledPixmap = pixmap.scaled(QtCore.QSize(400, 400)) self.label.setPixmap(myScaledPixmap) #make a sphere object size of window displayed to #label at the bottom of the frame sphere2 = Sphere(n=self.lcd5.value() + .0001j, r=self.lcd4.value(), center=(self.lcd.value(), self.lcd2.value(), self.lcd3.value())) self.sphObject.setText(repr(sphere2))
def test_AlphaModelholo_likelihood(): holo = get_example_data('image0001') s = Sphere( prior.Gaussian(.5, .1), prior.Gaussian(1.6, .1), (prior.Gaussian(5, 1), prior.Gaussian(5, 1), prior.Gaussian(5, 1))) model = AlphaModel(s, alpha=prior.Gaussian(.7, .1), noise_sd=.01) assert_pickle_roundtrip(model)
def test_calc_field(): s = Sphere(n=1.59, r=.5, center=(0, 0, 1)) t = update_metadata(detector_grid(shape=(2, 2), spacing=.1), illum_wavelen=0.66, medium_index=1.33, illum_polarization=(1, 0)) thry = Mie(False) f = calc_field(t, s, 1.33, .66, (1, 0), theory=thry) assert_obj_close(t.attrs, f.attrs) gold = xr.DataArray(np.array([[[ -3.95866810e-01 + 2.47924378e+00j, 0.00000000e+00 + 0.00000000e+00j, 0.00000000e+00 - 0.00000000e+00j ], [ -4.91260953e-01 + 2.32779296e+00j, 9.21716363e-20 - 5.72226912e-19j, 2.99878926e-18 - 1.41959276e-17j ]], [[ -4.89755627e-01 + 2.31844748e+00j, 0.00000000e+00 + 0.00000000e+00j, 4.89755627e-02 - 2.31844748e-01j ], [ -5.71886751e-01 + 2.17145168e+00j, 1.72579090e-03 - 8.72241140e-03j, 5.70160960e-02 - 2.16272927e-01j ]]]), dims=['x', 'y', 'vector'], coords={ 'x': t.x, 'y': t.y, 'vector': ['x', 'y', 'z'] }) assert abs((f - gold).max()) < 5e-9
def test_voxelated_complex(): s = Sphere(n = 1.2+2j, r = .2, center = (5,5,5)) sv = Scatterer(s.indicators, s.n, s.center) schema = detector_grid(10, .1) holo_dda = calc_holo(schema, sv, illum_wavelen=.66, medium_index=1.33, illum_polarization = (1, 0), theory=DDA) verify(holo_dda, 'dda_voxelated_complex', rtol=1e-5)
def test_serialization(): par_s = Sphere(center=(par(.567e-5, [0, 1e-5]), par(.576e-6, [0, 1e-5]), par(15e-6, [1e-5, 2e-5])), r=par(8.5e-7, [1e-8, 1e-5]), n=par(1.59, [1, 2])) alpha = par(.6, [.1, 1], 'alpha') schema = ImageSchema(shape=100, spacing=.1151e-6, optics=Optics(.66e-6, 1.33)) model = Model(par_s, Mie.calc_holo, alpha=alpha) holo = Mie.calc_holo(model.scatterer.guess, schema, model.alpha.guess) result = fit(model, holo) temp = tempfile.NamedTemporaryFile() save(temp, result) temp.flush() temp.seek(0) loaded = load(temp) assert_obj_close(result, loaded, context='serialized_result')
def test_holopy_hologram_equal_to_exact_calculation(self): # Checks that phase shifts and wrappers for mielens are correct theory_mielens = MieLens() illum_wavelength = 0.66 # 660 nm red light k = 2 * np.pi / illum_wavelength center = (10, 10, 5.) kwargs = {'particle_kz': center[2] * k, 'index_ratio': 1.2, 'size_parameter': 0.5 * k, 'lens_angle': theory_mielens.lens_angle} detector = detector_grid(10, 2.0) x = detector.x.values.reshape(-1, 1) - center[0] y = detector.y.values.reshape(1, -1) - center[1] rho = np.sqrt(x**2 + y**2) phi = np.arctan2(y, x) calculator = mielensfunctions.MieLensCalculator(**kwargs) scatterer = Sphere(n=kwargs['index_ratio'], r=kwargs['size_parameter'] / k, center=center) holo_calculate = calculator.calculate_total_intensity(k * rho, phi) holo_holopy = calc_holo( detector, scatterer, illum_wavelen=illum_wavelength, medium_index=1., illum_polarization=(1, 0), theory=theory_mielens) is_ok = np.allclose(holo_calculate, holo_holopy.values.squeeze(), **TOLS) self.assertTrue(is_ok)
def test_dda_fit(): s = Sphere(n=1.59, r=.2, center=(5, 5, 5)) o = Optics(wavelen=.66, index=1.33, pixel_scale=.1) schema = ImageSchema(optics=o, shape=100) h = Mie.calc_holo(s, schema) def make_scatterer(r, x, y, z): local_s = Sphere(r=r, center=(x, y, z)) return Scatterer(local_s.indicators, n=s.n) parameters = [ par(.18, [.1, .3], name='r', step=.1), par(5, [4, 6], 'x'), par(5, [4, 6], 'y'), par(5.2, [4, 6], 'z') ] p = Parametrization(make_scatterer, parameters) model = Model(p, DDA.calc_holo) res = fit(model, h) assert_parameters_allclose(res.parameters, dict([('r', 0.2003609439787491), ('x', 5.0128083665603995), ('y', 5.0125252883133617), ('z', 4.9775097284878775)]), rtol=1e-3)
def test_DDA_coated(): cs = Sphere( center=[7.141442573813124, 7.160766866147957, 11.095409800342143], n=[(1.27121212428+0j), (1.49+0j)], r=[.1-0.0055, 0.1]) lmie_holo = calc_holo(schema, cs, index, wavelen, theory=Mie) dda_holo = calc_holo(schema, cs, index, wavelen, theory=DDA) assert_allclose(lmie_holo, dda_holo, rtol = 5e-4)
def slideZ(self, value): #using reconstructions-- better to use electric field? ''' When z is changed, instead of recomputing the hologram, we use the shortcut of reconstructing the last computed hologram. ''' source = self.sender() start = time.time() if self.lastZ == self.lcd3.value(): self.holo = self.lastholo if self.lastZ < self.lcd3.value(): self.holo = self.lastholo self.warning.setText( 'Press calculate once you have all your parameters set') if self.lastZ > self.lcd3.value( ): #reconstructing a plane between hologram and object self.holo = np.abs( propagate(self.lastholo, -self.lcd3.value() + self.lastZ)) self.warning.setText('Reconstruction: hologram is approximate') end = time.time() #now take only the part that you want to display x = round(self.sld.value()) y = round(self.sld2.value()) selection = self.holo[256 - x:512 - x, 256 - y:512 - y] im = scipy.misc.toimage(selection) #PIL image #https://github.com/shuge/Enjoy-Qt-Python-Binding/blob/master/image/display_img/pil_to_qpixmap.py #myQtImage = ImageQt(im) #qimage = QtGui.QImage(myQtImage) if im.mode == "RGB": pass elif im.mode == "L": im = im.convert("RGBA") data = im.tostring('raw', "RGBA") qim = QtGui.QImage(data, 256, 256, QtGui.QImage.Format_ARGB32) pixmap = QtGui.QPixmap.fromImage(qim) myScaledPixmap = pixmap.scaled(QtCore.QSize(400, 400)) self.label.setPixmap(myScaledPixmap) #self.label.setGeometry(10, 10, 400, 400) #self.label.setScaledContents(True) self.timer.setGeometry(420, 400, 150, 30) self.timer.setText('Calc. Time: ' + str(round(end - start, 4)) + ' s') self.timer.setAlignment(QtCore.Qt.AlignBottom | QtCore.Qt.AlignCenter) sphere2 = Sphere(n=self.lcd5.value() + .0001j, r=self.lcd4.value(), center=(self.lcd.value(), self.lcd2.value(), self.lcd3.value())) self.sphObject.setText(repr(sphere2))
def test_csg_construction(): s = Sphere(n = 1.6, r=.5, center=(0, 0, 0)) st = s.translated(.4, 0, 0) pacman = Difference(s, st) assert_allclose(pacman.bounds, [(-.5, .5), (-.5, .5), (-.5, .5)])