def test_shift(self):
"""
check that .shift works
"""
# First, test simple behaviour on the VA
self.scanner.scale.value = (1, 1)
self.scanner.resolution.value = self.scanner.resolution.range[1]
self.scanner.horizontalFoV.value = self.scanner.horizontalFoV.range[0]
self.scanner.shift.value = (0, 0)
self.assertEqual(self.scanner.shift.value, (0, 0))
# normal acquisition
im_no_shift = self.sed.data.get()
self.assertEqual(im_no_shift.shape,
self.scanner.resolution.value[-1::-1])
# shift a bit
self.scanner.shift.value = (-1.26e-6, 3e-6) # m
im_small_shift = self.sed.data.get()
test.assert_array_not_equal(im_no_shift, im_small_shift)
# shift min/max
self.scanner.shift.value = self.scanner.shift.range[0][
1], self.scanner.shift.range[1][0]
im_big_shift = self.sed.data.get()
test.assert_array_not_equal(im_no_shift, im_big_shift)
def test_acquire_ar_pol(self):
"""
Acquire image with text of current polarization position written on top.
"""
self.assertGreaterEqual(len(self.camera.shape), 3)
exposure = 0.1
self._ensureExp(exposure)
self.camera.updateMetadata({model.MD_POL_MODE: "lhc"})
# get image from camera
im_lhc = self.camera.data.get()
self.camera.updateMetadata({model.MD_POL_MODE: "rhc"})
# get image from camera
im_rhc = self.camera.data.get()
# test the two images are different from each other (different txt was written on top)
assert_array_not_equal(im_lhc, im_rhc)
# change binning
self.camera.binning.value = (2, 2)
self.camera.updateMetadata({model.MD_POL_MODE: "horizontal"})
# get image from camera
im_horizontal = self.camera.data.get()
self.camera.updateMetadata({model.MD_POL_MODE: "vertical"})
# get image from camera
im_vertical = self.camera.data.get()
# test the two images are different from each other (different txt was written on top)
assert_array_not_equal(im_horizontal, im_vertical)
def test_shift(self):
"""
check that .shift works
This only works on the "drifting" version because on this version the
max resolution is limited compared to the full image, so a shift is possible.
"""
# First, test simple behaviour on the VA
self.scanner.scale.value = (1, 1)
self.scanner.resolution.value = self.scanner.resolution.range[1]
self.scanner.horizontalFoV.value = self.scanner.horizontalFoV.range[0]
self.scanner.shift.value = (0, 0)
self.assertEqual(self.scanner.shift.value, (0, 0))
# normal acquisition
im_no_shift = self.sed.data.get()
self.assertEqual(im_no_shift.shape,
self.scanner.resolution.value[-1::-1])
# shift a bit
self.scanner.shift.value = (-1.26e-6, 3e-6) # m
im_small_shift = self.sed.data.get()
test.assert_array_not_equal(im_no_shift, im_small_shift)
# shift min/max
self.scanner.shift.value = self.scanner.shift.range[0][
1], self.scanner.shift.range[1][0]
im_big_shift = self.sed.data.get()
test.assert_array_not_equal(im_no_shift, im_big_shift)
def test_cryo_feature_overlay(self):
"""
Test behavior of CryoFeatureOverlay
"""
cnvs = miccanvas.DblMicroscopeCanvas(self.panel)
self.add_control(cnvs, wx.EXPAND, proportion=1, clear=True)
tab_mod = self.create_cryo_tab_model()
# Create a dummy stage & focus to attach to the view
stage = TMCLController(name="test_stage",
role="stage",
port="/dev/fake3",
axes=["x", "y"],
ustepsize=[1e-6, 1e-6],
rng=[[-3e-3, 3e-3], [-3e-3, 3e-3]],
refproc="Standard")
focus = TMCLController(name="test_focus",
role="focus",
port="/dev/fake3",
axes=["z"],
ustepsize=[1e-6],
rng=[[-3e-3, 3e-3]],
refproc="Standard")
tab_mod.main.stage = stage
tab_mod.main.focus = focus
fview = FeatureOverviewView("fakeview", stage=stage)
tab_mod.views.value.append(fview)
tab_mod.focussedView.value = fview
cnvs.setView(fview, tab_mod)
# Save current empty canvas
img = wx.Bitmap.ConvertToImage(cnvs._bmp_buffer)
buffer_clear = wxImage2NDImage(img)
cryofeature_overlay = wol.CryoFeatureOverlay(cnvs, tab_mod)
cnvs.add_world_overlay(cryofeature_overlay)
cryofeature_overlay.active.value = True
# Add features to the tab's features list
tab_mod.add_new_feature(0, 0)
tab_mod.add_new_feature(0.001, 0.001)
cnvs._dc_buffer.SelectObject(wx.NullBitmap) # Flush the buffer
cnvs._dc_buffer.SelectObject(cnvs._bmp_buffer)
img = wx.Bitmap.ConvertToImage(cnvs._bmp_buffer)
buffer_feature = wxImage2NDImage(img)
# Compare empty canvas with the added _features_va
assert_array_not_equal(
buffer_clear,
buffer_feature,
msg=
"Buffers are equal, which means the added _features_va didn't appear on the canvas."
)
test.gui_loop()
def test_current_pos_crosshair_overlay(self):
"""
Test behaviour of CurrentPosCrossHairOverlay
"""
cnvs = miccanvas.DblMicroscopeCanvas(self.panel)
self.add_control(cnvs, wx.EXPAND, proportion=1, clear=True)
tab_mod = self.create_simple_tab_model()
# create a dummy stage to attach to the view
stage = TMCLController(name="test",
role="test",
port="/dev/fake3",
axes=["x", "y"],
ustepsize=[1e-6, 1e-6],
rng=[[-3e-3, 3e-3], [-3e-3, 3e-3]],
refproc="Standard")
# Add a tiled area view to the tab model
logging.debug(stage.position.value)
fview = FeatureOverviewView("fakeview", stage=stage)
tab_mod.views.value.append(fview)
tab_mod.focussedView.value = fview
cnvs.setView(fview, tab_mod)
cnvs.view.show_crosshair.value = False
slol = wol.CurrentPosCrossHairOverlay(cnvs)
slol.active.value = True
cnvs.add_world_overlay(slol)
# stage start at 0,0 (cross hair at center) -> move bt 1mm, 1mm -> then back to 0,0
stage.moveAbs({'x': 1e-3, 'y': 1e-3}).result()
img = wx.Bitmap.ConvertToImage(cnvs._bmp_buffer)
buffer_ch_move = wxImage2NDImage(img)
test.gui_loop(1)
stage.moveAbs({'x': 0, 'y': 0}).result()
cnvs.update_drawing()
cnvs._dc_buffer.SelectObject(wx.NullBitmap) # Flush the buffer
cnvs._dc_buffer.SelectObject(cnvs._bmp_buffer)
img = wx.Bitmap.ConvertToImage(cnvs._bmp_buffer)
buffer_ch_center = wxImage2NDImage(img)
assert_array_not_equal(
buffer_ch_center,
buffer_ch_move,
msg=
"Buffers are equal, which means the crosshair didn't change on stage movement."
)
test.gui_loop()
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_label_overlay(self):
logging.getLogger().setLevel(logging.DEBUG)
cnvs = miccanvas.DblMicroscopeCanvas(self.panel)
tab_mod = self.create_simple_tab_model()
tab_mod.tool.choices |= {TOOL_RULER, TOOL_LABEL}
view = tab_mod.focussedView.value
self.add_control(cnvs, wx.EXPAND, proportion=1, clear=True)
cnvs.setView(view, tab_mod)
gol = cnvs.gadget_overlay
test.gui_loop(0.1)
# gadget overlay with no tools
img = wx.Bitmap.ConvertToImage(cnvs._bmp_buffer)
buffer_empty = wxImage2NDImage(img)
self.assertTrue(numpy.all(buffer_empty == 0))
# Create a "big label"
p_start_pos = (-0.00055, -0.00055)
p_end_pos = (0.00055, 0.00055)
label = wol.LabelGadget(cnvs, p_start_pos, p_end_pos)
label.text = 'label1'
gol._tools.append(label)
# Create a 10 px label
v_start_pos = (500, 500)
v_end_pos = (500, 510)
offset = cnvs.get_half_buffer_size()
p_start_pos = cnvs.view_to_phys(v_start_pos, offset)
p_end_pos = cnvs.view_to_phys(v_end_pos, offset)
label = wol.LabelGadget(cnvs, p_start_pos, p_end_pos)
label.text = 'label2'
gol._tools.append(label)
# Create a 1 px label
b_start_pos = (599, 670)
b_end_pos = (599, 671)
offset = cnvs.get_half_buffer_size()
p_start_pos = cnvs.buffer_to_phys(b_start_pos, offset)
p_end_pos = cnvs.buffer_to_phys(b_end_pos, offset)
label = wol.LabelGadget(cnvs, p_start_pos, p_end_pos)
label.text = 'label3'
gol._tools.append(label)
# Add one ruler that will become the selected ruler
p_start_pos = (0, 0)
p_end_pos = (0, 0.00035)
selected_label = wol.LabelGadget(cnvs, p_start_pos, p_end_pos)
selected_label.text = 'label4'
gol._tools.append(selected_label)
# update drawing
cnvs.update_drawing()
test.gui_loop(0.1)
# ruler overlay with 4 labels
cnvs._dc_buffer.SelectObject(wx.NullBitmap) # Flush the buffer
cnvs._dc_buffer.SelectObject(cnvs._bmp_buffer)
img = wx.Bitmap.ConvertToImage(cnvs._bmp_buffer)
new_buffer = wxImage2NDImage(img)
assert_array_not_equal(
buffer_empty,
new_buffer,
msg="Buffers are equal, which means that the labels were not drawn"
)
# make the last label the selected one (highlighted)
gol._selected_tool = selected_label
gol._selected_tool.text = 'selected_label'
cnvs.update_drawing()
test.gui_loop(0.1)
# ruler overlay with 4 labels, 1 of them is selected (highlighted)
cnvs._dc_buffer.SelectObject(wx.NullBitmap) # Flush the buffer
cnvs._dc_buffer.SelectObject(cnvs._bmp_buffer)
img = wx.ImageFromBitmap(cnvs._bmp_buffer)
sel_buffer = wxImage2NDImage(img)
assert_array_not_equal(
new_buffer,
sel_buffer,
msg="Buffers are equal, which means that the labels were not drawn"
)
# Create a ruler
v_start_pos = (500, 500)
v_end_pos = (500, 510)
offset = cnvs.get_half_buffer_size()
p_start_pos = cnvs.view_to_phys(v_start_pos, offset)
p_end_pos = cnvs.view_to_phys(v_end_pos, offset)
ruler = wol.RulerGadget(cnvs, p_start_pos, p_end_pos)
gol._tools.append(ruler)
# Update drawing
cnvs.update_drawing()
test.gui_loop(0.1)
# Gadget overlay with 4 rulers and 1 label
# Ruler overlay with 4 rulers
cnvs._dc_buffer.SelectObject(wx.NullBitmap) # Flush the buffer
cnvs._dc_buffer.SelectObject(cnvs._bmp_buffer)
img = wx.Bitmap.ConvertToImage(cnvs._bmp_buffer)
rul_buffer = wxImage2NDImage(img)
assert_array_not_equal(
sel_buffer,
rul_buffer,
msg="Buffers are equal, which means that the ruler was not drawn")
