def test_binning(self):
"""
Changing the binning shouldn't affect the position
binning x2 => same position (so shift in pixel / 2)
"""
# At pos 0, 0
im0 = self.camera.data.get()
# Move a little bit in X,Y => should have a different image shifted by the same amount
self.camera.updateMetadata({model.MD_POS: (10e-6, 20e-6)})
im_move1 = self.camera.data.get()
# Change to binning 2
self.camera.binning.value = (2, 2)
self.camera.updateMetadata({model.MD_PIXEL_SIZE: (2e-6, 2e-6)
}) # Normally updated by the mdupdater
im_move2 = self.camera.data.get()
assert_tuple_almost_equal((0, 0),
MeasureShift(im_move1[::2, ::2], im_move2,
10),
delta=0.5)
assert_tuple_almost_equal((5, -10),
MeasureShift(im0[::2, ::2], im_move2, 10),
delta=0.5)
def test_roi(self):
"""
check that .translation and .binning work
"""
# First, test simple behaviour on the VA
# max resolution
max_res = self.camera.resolution.range[1]
self.camera.binning.value = (1, 1)
self.camera.resolution.value = max_res
self.camera.translation.value = (
-1, 1) # will be set back to 0,0 as it cannot move
self.assertEqual(self.camera.translation.value, (0, 0))
# binning
self.camera.binning.value = (16, 16)
exp_res = (max_res[0] // 16, max_res[1] // 16)
assert_tuple_almost_equal(self.camera.resolution.value, exp_res)
self.camera.translation.value = (-1, 1)
self.assertEqual(self.camera.translation.value, (0, 0))
# translation
exp_res = (max_res[0] // 32, max_res[1] // 32)
self.camera.resolution.value = exp_res
self.camera.translation.value = (-1, 1)
assert_tuple_almost_equal(self.camera.resolution.value, exp_res)
self.assertEqual(self.camera.translation.value, (-1, 1))
self.camera.binning.value = (1, 1)
self.camera.resolution.value = self.camera.resolution.range[1]
self.camera.translation.value = (0, 0)
def test_roi(self):
"""
check that .translation and .scale work
"""
# max resolution
max_res = self.scanner.resolution.range[1]
# shift
exp_res = (max_res[0] // 2, max_res[1] // 2)
self.scanner.resolution.value = exp_res
self.scanner.translation.value = (-1, 1)
test.assert_tuple_almost_equal(self.scanner.resolution.value, exp_res)
self.assertEqual(self.scanner.translation.value, (-1, 1))
self.scanner.translation.value = (0, 0)
self.scanner.resolution.value = max_res
self.scanner.scale.value = (2, 2)
self.scanner.dwellTime.value = self.scanner.dwellTime.range[0]
# normal acquisition
im = self.sed.data.get()
self.assertEqual(im.shape, self.scanner.resolution.value[-1::-1])
# shift a bit
# reduce the size of the image so that we can have translation
self.scanner.translation.value = (-10, 10) # px
im = self.sed.data.get()
self.assertEqual(im.shape, self.scanner.resolution.value[-1::-1])
# only one point
self.scanner.resolution.value = (1, 1)
im = self.sed.data.get()
self.assertEqual(im.shape, self.scanner.resolution.value[-1::-1])
def test_write_time(self):
startt = time.time()
shift = (-3e-6, 1e-6)
self.bc.shift.value = shift
self.assertLess(time.time() - startt, 0.03,
"Reading/writing took more than 30 ms.")
logging.debug("Shift value set to %s", self.bc.shift.value)
test.assert_tuple_almost_equal(self.bc.shift.value, shift, places=7)
def test_transform_coordinates(self):
val = (0, 4e-6)
md = ((-0.00027788219369730165, 0.0013604844623992785),
(0.00012699407486043473, -0.0006217507619527259),
(-0.0013604844623992785, -0.00027788219369730165),
(0.0006217507619527259, 0.00012699407486043473))
expected = [0x6f7e, 0x835f, 0x7874,
0x7e75] # from testing with example script
ret = tfsbc.transform_coordinates(val, *md)
self.assertEqual(ret, expected)
rev = tfsbc.transform_coordinates_reverse(ret, *md)
test.assert_tuple_almost_equal(val, rev, places=5)
def test_save(self):
conf = gui.conf.get_calib_conf()
shid = 125166841353
# try with a bit annoying numbers
htop = (-0.5, 1e-6)
hbot = (5e9, -1.55158e-6)
hfoc = 0.006
ofoc = -0.001e-6
strans = (5.468e-3, -365e-6)
sscale = (1.1, 0.9)
srot = 0.1
iscale = (13.1, 13.1)
irot = 5.9606
iscale_xy = (1.01, 0.9)
ishear = 1.1
resa = (8.09, 2.16)
resb = (-157.5, -202.9)
hfwa = (-0.953, -0.009)
scaleshift = (0.029, -2.90e-05)
orig_calib = (htop, hbot, hfoc, ofoc, strans, sscale, srot, iscale, irot,
iscale_xy, ishear, resa, resb, hfwa, scaleshift)
conf.set_sh_calib(shid, *orig_calib)
# read back from memory
back_calib = conf.get_sh_calib(shid)
for o, b in zip(orig_calib, back_calib):
if isinstance(o, tuple):
test.assert_tuple_almost_equal(o, b)
else:
self.assertAlmostEqual(o, b)
# read back from file
del conf
gui.conf.CONF_CALIB = None
conf = gui.conf.get_calib_conf()
back_calib = conf.get_sh_calib(shid)
for o, b in zip(orig_calib, back_calib):
if isinstance(o, tuple):
test.assert_tuple_almost_equal(o, b)
else:
self.assertAlmostEqual(o, b)
def test_move_around(self):
"""
Test that moving the "stage" moves the image
"""
# At pos 0, 0
im0 = self.camera.data.get()
self.assertEqual(self.camera.resolution.value[::-1], im0.shape[:2])
im1 = self.camera.data.get()
assert_tuple_almost_equal((0, 0),
MeasureShift(im0, im1, 10),
delta=0.5)
# Move a little bit in X,Y => should have a different image shifted by the same amount
self.camera.updateMetadata({model.MD_POS: (10e-6, 20e-6)})
im_move1 = self.camera.data.get()
# Y is opposite direction in pixels, compared to physical
assert_tuple_almost_equal((10, -20),
MeasureShift(im0, im_move1, 10),
delta=0.5)
# Move a little bit => should have a different image
self.camera.updateMetadata({model.MD_POS: (100e-6, 200e-6)})
im_move1 = self.camera.data.get()
# Note: images are always different, due to synthetic noise
test.assert_array_not_equal(im0, im_move1)
# Move the opposite direction
self.camera.updateMetadata({model.MD_POS: (-100e-6, -200e-6)})
im_move2 = self.camera.data.get()
test.assert_array_not_equal(im0, im_move2)
test.assert_array_not_equal(im_move1, im_move2)
# Move far => should "block" on the border
self.camera.updateMetadata({model.MD_POS: (-1000e-6, -2000e-6)})
im_move_f1 = self.camera.data.get()
# test.assert_array_not_equal(im0, im_move_f1)
# Move even further => no change
self.camera.updateMetadata({model.MD_POS: (-10000e-6, -20000e-6)})
im_move_f2 = self.camera.data.get()
def test_shifts(self):
"""
Move to different shifts, test if .shift VA is updated correctly. Wait in between,
so the effect can be seen on the hardware.
"""
shift = (0, 0)
self.bc.shift.value = shift
test.assert_tuple_almost_equal(self.bc.shift.value, shift, places=7)
time.sleep(1)
shift = (-5e-6, 0)
self.bc.shift.value = shift
test.assert_tuple_almost_equal(self.bc.shift.value, shift, places=7)
time.sleep(1)
shift = (-5e-6, -5e-6)
self.bc.shift.value = shift
test.assert_tuple_almost_equal(self.bc.shift.value, shift, places=7)
time.sleep(1)
shift = (0, -5e-6)
self.bc.shift.value = shift
test.assert_tuple_almost_equal(self.bc.shift.value, shift, places=7)
shift = (0, 0)
self.bc.shift.value = shift
test.assert_tuple_almost_equal(self.bc.shift.value, shift, places=7)
# Large shift
shift = (500e-6, 0)
with self.assertRaises(ValueError):
self.bc.shift.value = shift
shift = (0, 500e-6)
with self.assertRaises(ValueError):
self.bc.shift.value = shift
def test_roi(self):
"""
check that .translation and .scale work
"""
# First, test simple behaviour on the VA
# max resolution
max_res = self.scanner.resolution.range[1]
self.scanner.scale.value = (1, 1)
self.scanner.resolution.value = max_res
self.scanner.translation.value = (-1, 1) # will be set back to 0,0 as it cannot move
self.assertEqual(self.scanner.translation.value, (0, 0))
# scale up
self.scanner.scale.value = (16, 16)
exp_res = (max_res[0] // 16, max_res[1] // 16)
test.assert_tuple_almost_equal(self.scanner.resolution.value, exp_res)
self.scanner.translation.value = (-1, 1)
self.assertEqual(self.scanner.translation.value, (0, 0))
# shift
exp_res = (max_res[0] // 32, max_res[1] // 32)
self.scanner.resolution.value = exp_res
self.scanner.translation.value = (-1, 1)
test.assert_tuple_almost_equal(self.scanner.resolution.value, exp_res)
self.assertEqual(self.scanner.translation.value, (-1, 1))
# change scale to some float
self.scanner.resolution.value = (max_res[0] // 16, max_res[1] // 16)
self.scanner.scale.value = (1.5, 2.3)
exp_res = (max_res[0] // 1.5, max_res[1] // 2.3)
test.assert_tuple_almost_equal(self.scanner.resolution.value, exp_res)
self.assertEqual(self.scanner.translation.value, (0, 0))
self.scanner.scale.value = (1, 1)
test.assert_tuple_almost_equal(self.scanner.resolution.value, max_res, delta=2.1)
self.assertEqual(self.scanner.translation.value, (0, 0))
# Then, check metadata fits with the expectations
center = (1e3, -2e3) #m
# simulate the information on the position (normally from the mdupdater)
self.scanner.updateMetadata({model.MD_POS: center})
self.scanner.resolution.value = max_res
self.scanner.scale.value = (16, 16)
self.scanner.dwellTime.value = self.scanner.dwellTime.range[0]
# normal acquisition
im = self.sed.data.get()
self.assertEqual(im.shape, self.scanner.resolution.value[-1::-1])
test.assert_tuple_almost_equal(im.metadata[model.MD_POS], center)
# shift a bit
# reduce the size of the image so that we can have translation
self.scanner.resolution.value = (max_res[0] // 32, max_res[1] // 32)
self.scanner.translation.value = (-1.26, 10) # px
pxs = self.scanner.pixelSize.value
exp_pos = (center[0] + (-1.26 * pxs[0]),
center[1] - (10 * pxs[1])) # because translation Y is opposite from physical one
im = self.sed.data.get()
self.assertEqual(im.shape, self.scanner.resolution.value[-1::-1])
test.assert_tuple_almost_equal(im.metadata[model.MD_POS], exp_pos)
# only one point
self.scanner.resolution.value = (1,1)
im = self.sed.data.get()
self.assertEqual(im.shape, self.scanner.resolution.value[-1::-1])
test.assert_tuple_almost_equal(im.metadata[model.MD_POS], exp_pos)
def test_read_write(self):
vals = [27000, 37000, 20000, 44000]
self.bc._write_registers(vals)
ret = self.bc._read_registers()
test.assert_tuple_almost_equal(vals, list(ret), places=1)