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_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_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_image_io():
holo = get_example_data('image0001.yaml')
t = tempfile.mkdtemp()
filename = os.path.join(t, 'image0001.tif')
save(filename, holo)
l = load(filename)
assert_obj_close(l, holo)
# check that it defaults to saving as tif
filename = os.path.join(t, 'image0002')
save_image(filename, holo)
l = load(filename + '.tif')
assert_obj_close(l, holo)
# check saving 16 bit
filename = os.path.join(t, 'image0003')
save_image(filename, holo, scaling=None, depth=16)
l = load(filename + '.tif')
assert_obj_close(l, holo)
# test that yaml save works corretly with a string instead of a file
filename = os.path.join(t, 'image0001.yaml')
save(filename, holo)
loaded = load(filename)
assert_obj_close(loaded, holo)
f = get_example_data_path('image0001.yaml')
spacing = .1
optics = Optics(.66, 1.33, (1, 0))
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
h = load(f, spacing=spacing, optics=optics)
assert_obj_close(h.optics, optics)
assert_equal(h.spacing, spacing)
assert_equal(len(w), 1)
assert "Overriding spacing and optics of loaded yaml" in w[-1].message
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
h = load(f, optics=optics)
assert_obj_close(h.optics, optics)
assert_equal(h.spacing, holo.spacing)
assert_equal(len(w), 1)
assert ("WARNING: overriding optics of loaded yaml without "
"overriding spacing, this is probably incorrect."
in w[-1].message)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
h = load(f, spacing=spacing)
assert_obj_close(h.optics, holo.optics)
assert_equal(h.spacing, spacing)
assert_equal(len(w), 1)
assert ("WARNING: overriding spacing of loaded yaml without "
"overriding optics, this is probably incorrect."
in w[-1].message)
shutil.rmtree(t)
def test_layered():
s = Sphere(n = (1,2), r = (1, 2), center = (2, 2, 2))
sch = ImageSchema((10, 10), .2, Optics(.66, 1, (1, 0)))
hs = Mie.calc_holo(s, sch)
guess = hp.scattering.scatterer.sphere.LayeredSphere((1,2), (par(1.01), par(.99)), (2, 2, 2))
model = Model(guess, Mie.calc_holo)
res = fit(model, hs)
assert_allclose(res.scatterer.t, (1, 1), rtol = 1e-12)
def test_load_optics():
optics_yaml = """wavelen: 785e-9
polarization: [1.0, 0]
divergence: 0
pixel_size: [6.8e-6, 6.8e-6]
pixel_scale: [3.3e-7, 3.3e-7]"""
t = tempfile.TemporaryFile()
t.write(optics_yaml)
t.seek(0)
o = Optics(**load(t))
assert_obj_close(
o,
Optics(wavelen=7.85e-07,
polarization=[1.0, 0.0],
divergence=0,
pixel_size=[6.8e-06, 6.8e-06],
pixel_scale=[3.3e-07, 3.3e-07]))
def test_fit_multisphere_noisydimer_slow():
optics = Optics(wavelen=658e-9, polarization = [0., 1.0],
divergence = 0., pixel_scale = [0.345e-6, 0.345e-6],
index = 1.334)
holo = normalize(get_example_data('image0002.yaml'))
# Now construct the model, and fit
parameters = [Parameter(name = 'x0', guess = 1.64155e-5,
limit = [0, 1e-4]),
Parameter(1.7247e-5, [0, 1e-4], 'y0'),
Parameter(20.582e-6, [0, 1e-4], 'z0'),
Parameter(.6856e-6, [1e-8, 1e-4], 'r0'),
Parameter(1.6026, [1, 2], 'nr0'),
Parameter(1.758e-5, [0, 1e-4], 'x1'),
Parameter(1.753e-5, [0, 1e-4], 'y1'),
Parameter(21.2698e-6, [1e-8, 1e-4], 'z1'),
Parameter(.695e-6, [1e-8, 1e-4], 'r1'),
Parameter(1.6026, [1, 2], 'nr1')]
def make_scatterer(x0, x1, y0, y1, z0, z1, r0, r1, nr0, nr1):
s = Spheres([
Sphere(center = (x0, y0, z0), r=r0, n = nr0+1e-5j),
Sphere(center = (x1, y1, z1), r=r1, n = nr1+1e-5j)])
return s
# initial guess
#s1 = Sphere(n=1.6026+1e-5j, r = .6856e-6,
# center=(1.64155e-05, 1.7247e-05, 20.582e-6))
#s2 = Sphere(n=1.6026+1e-5j, r = .695e-6,
# center=(1.758e-05, 1.753e-05, 21.2698e-6))
#sc = Spheres([s1, s2])
#alpha = 0.99
#lb1 = Sphere(1+1e-5j, 1e-8, 0, 0, 0)
#ub1 = Sphere(2+1e-5j, 1e-5, 1e-4, 1e-4, 1e-4)
#step1 = Sphere(1e-4+1e-4j, 1e-8, 0, 0, 0)
#lb = Spheres([lb1, lb1]), .1
#ub = Spheres([ub1, ub1]), 1
#step = Spheres([step1, step1]), 0
model = Model(parameters, Multisphere, make_scatterer=make_scatterer, alpha
= Parameter(.99, [.1, 1.0], 'alpha'))
result = fit(model, holo)
print result.scatterer
gold = np.array([1.642e-5, 1.725e-5, 2.058e-5, 1e-5, 1.603, 6.857e-7,
1.758e-5, 1.753e-5, 2.127e-5, 1e-5, 1.603,
6.964e-7])
gold_alpha = 1.0
assert_parameters_allclose(result.scatterer, gold, rtol=1e-2)
# TODO: This test fails, alpha comes back as .9899..., where did
# the gold come from?
assert_approx_equal(result.alpha, gold_alpha, significant=2)
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_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_n():
sph = Sphere(par(.5), 1.6, (5,5,5))
sch = ImageSchema(shape=[100, 100], spacing=[0.1, 0.1],
optics=Optics(wavelen=0.66,
index=1.33,
polarization=[1, 0],
divergence=0.0),
origin=[0.0, 0.0, 0.0])
model = Model(sph, Mie.calc_holo, alpha=1)
holo = Mie.calc_holo(model.scatterer.guess, sch)
coster = CostComputer(holo, model, random_subset=.1)
assert_allclose(coster.flattened_difference({'n' : .5}), 0)
import holopy as hp
from holopy.scattering.scatterer import Sphere
from holopy.scattering.theory import Mie
from holopy.core import ImageSchema, Optics
schema = ImageSchema(shape=100,
spacing=.1,
optics=Optics(wavelen=.660,
index=1.33,
polarization=[1, 0]))
cs = Sphere(center=(2.5, 5, 5), n = (1.59, 1.42),\
r = (0.3, 0.6))
holo = Mie.calc_holo(cs, schema)
hp.show(holo)
import matplotlib.pyplot as plt
import numpy as np
from holopy.core import Schema, Angles, Optics
from holopy.scattering.scatterer import Sphere
from holopy.scattering.theory import Mie
schema = Schema(positions=Angles(np.linspace(0, np.pi, 100)),
optics=Optics(wavelen=.66, index=1.33, polarization=(1, 0)))
sphere = Sphere(r=.5, n=1.59)
matr = Mie.calc_scat_matrix(sphere, schema)
# It is typical to look at scattering matrices on a semilog plot.
# You can make one as follows:
plt.figure()
plt.semilogy(np.linspace(0, np.pi, 100), abs(matr[:, 0, 0])**2)
plt.semilogy(np.linspace(0, np.pi, 100), abs(matr[:, 1, 1])**2)
plt.show()