def setUpClass(cls):
try:
test.start_backend(SPARC2_FOCUS_CONFIG)
except LookupError:
logging.info("A running backend is already found, skipping tests")
cls.backend_was_running = True
return
except IOError as exp:
logging.error(str(exp))
raise
# find components by their role
cls.ccd = model.getComponent(role="ccd")
cls.spccd = model.getComponent(role="sp-ccd")
cls.focus = model.getComponent(role="focus")
cls.spgr = model.getComponent(role="spectrograph")
cls.spgr_ded = model.getComponent(role="spectrograph-dedicated")
cls.bl = model.getComponent(role="brightlight")
cls.microscope = model.getMicroscope()
cls.optmngr = path.OpticalPathManager(cls.microscope)
cls.specline_ccd = stream.BrightfieldStream("Spectrograph_line_ccd", cls.ccd, cls.ccd.data, cls.bl)
cls.specline_spccd = stream.BrightfieldStream ("Spectrograph line_spccd", cls.spccd, cls.spccd.data, cls.bl)
# The good focus position is the start up position
cls._good_focus = cls.focus.position.value["z"]
def setUpClass(cls):
try:
test.start_backend(SECOM_CONFIG)
except LookupError:
logging.info("A running backend is already found, skipping tests")
cls.backend_was_running = True
return
except IOError as exp:
logging.error(str(exp))
raise
# create some streams connected to the backend
cls.microscope = model.getMicroscope()
cls.ccd = model.getComponent(role="ccd")
cls.ebeam = model.getComponent(role="e-beam")
cls.sed = model.getComponent(role="se-detector")
cls.light = model.getComponent(role="light")
cls.light_filter = model.getComponent(role="filter")
s1 = stream.FluoStream("fluo1", cls.ccd, cls.ccd.data, cls.light,
cls.light_filter)
s1.excitation.value = sorted(s1.excitation.choices)[0]
s2 = stream.FluoStream("fluo2", cls.ccd, cls.ccd.data, cls.light,
cls.light_filter)
s2.excitation.value = sorted(s2.excitation.choices)[-1]
s3 = stream.BrightfieldStream("bf", cls.ccd, cls.ccd.data, cls.light)
cls.streams = [s1, s2, s3]
def test_metadata(self):
"""
Check if extra metadata are saved
"""
settings_obs = SettingsObserver(model.getComponents())
self.ccd.binning.value = (
1, 1) # make sure we don't save the right metadata by accident
detvas = {'exposureTime', 'binning', 'gain'}
s1 = stream.FluoStream("fluo2",
self.ccd,
self.ccd.data,
self.light,
self.light_filter,
detvas=detvas)
s2 = stream.BrightfieldStream("bf",
self.ccd,
self.ccd.data,
self.light,
detvas=detvas)
# Set different binning values for each stream
s1.detBinning.value = (2, 2)
s2.detBinning.value = (4, 4)
st = stream.StreamTree(streams=[s1, s2])
f = acqmng.acquire(st.getProjections(), settings_obs=settings_obs)
data, e = f.result()
for s in data:
self.assertTrue(model.MD_EXTRA_SETTINGS in s.metadata,
"Stream %s didn't save extra metadata." % s)
self.assertEqual(
data[0].metadata[model.MD_EXTRA_SETTINGS][self.ccd.name]
['binning'], [(2, 2), 'px'])
self.assertEqual(
data[1].metadata[model.MD_EXTRA_SETTINGS][self.ccd.name]
['binning'], [(4, 4), 'px'])
def addBrightfield(self, **kwargs):
"""
Creates a new brightfield stream and panel in the stream bar
returns (StreamPanel): the stream panel created
"""
s = acqstream.BrightfieldStream("Bright-field",
self._main_data_model.ccd,
self._main_data_model.ccd.data,
self._main_data_model.light)
return self._addStream(s, **kwargs)
def __init__(self, microscope, main_app):
"""
:param microscope: (Microscope or None) The main back-end component.
:param main_app: (wx.App) The main GUI component.
"""
super(CLAcqPlugin, self).__init__(microscope, main_app)
# Can only be used with a microscope
if not microscope:
return
else:
# Check which stream the microscope supports
self.main_data = self.main_app.main_data
if not (self.main_data.ccd and self.main_data.ebeam):
return
self.exposureTime = self.main_data.ccd.exposureTime
self.binning = self.main_data.ccd.binning
# Trick to pass the component (ccd to binning_1d_from_2d())
self.vaconf["binning"]["choices"] = (
lambda cp, va, cf: cutil.binning_1d_from_2d(
self.main_data.ccd, va, cf))
self._survey_stream = None
self._optical_stream = acqstream.BrightfieldStream(
"Optical",
self.main_data.ccd,
self.main_data.ccd.data,
emitter=None,
focuser=self.main_data.focus)
self._secom_cl_stream = SECOMCLSettingsStream("Secom-CL",
self.main_data.ccd,
self.main_data.ccd.data,
self.main_data.ebeam)
self._sem_stream = acqstream.SEMStream(
"Secondary electrons concurrent", self.main_data.sed,
self.main_data.sed.data, self.main_data.ebeam)
self._secom_sem_cl_stream = SECOMCLSEMMDStream(
"SECOM SEM CL", [self._sem_stream, self._secom_cl_stream])
self._driftCorrector = leech.AnchorDriftCorrector(
self.main_data.ebeam, self.main_data.sed)
self.conf = get_acqui_conf()
self.expectedDuration = model.VigilantAttribute(1,
unit="s",
readonly=True)
self.exposureTime.subscribe(self._update_exp_dur)
self.filename = self._secom_sem_cl_stream.filename # duplicate VA
self.filename.subscribe(self._on_filename)
self.addMenu("Acquisition/CL acquisition...", self.start)
def __init__(self, main_data, tab_data, overview_canvas, m_view):
self._data_model = tab_data
self.canvas = overview_canvas
self.m_view = m_view
self.main_data = main_data
self.curr_s = None
# Timer to detect when the stage ends moving
self._timer_pos = wx.PyTimer(self.add_pos_to_history)
m_view.merge_ratio.subscribe(self._on_merge_ratio_change)
if tab_data.main.stage:
tab_data.main.stage.position.subscribe(self.on_stage_pos_change, init=True)
tab_data.main.chamberState.subscribe(self._on_chamber_state)
tab_data.streams.subscribe(self._on_current_stream)
# Global overview image (Delphi)
if main_data.overview_ccd:
# Overview camera can be RGB => in that case len(shape) == 4
if len(main_data.overview_ccd.shape) == 4:
overview_stream = acqstream.RGBCameraStream("Overview", main_data.overview_ccd,
main_data.overview_ccd.data, None,
acq_type=MD_AT_OVV_FULL)
else:
overview_stream = acqstream.BrightfieldStream("Overview", main_data.overview_ccd,
main_data.overview_ccd.data, None,
acq_type=MD_AT_OVV_FULL)
self.m_view.addStream(overview_stream)
# TODO: add it to self.tab_data_model.streams?
else:
# black image to display history overlay separately from built-up ovv image
# controlled by merge slider
da, _ = self._initialize_ovv_im(OVV_SHAPE)
history_stream = acqstream.RGBUpdatableStream("History Stream", da, acq_type=MD_AT_HISTORY)
self.m_view.addStream(history_stream)
# Built-up overview image
self.ovv_im, self.m_view.mpp.value = self._initialize_ovv_im(OVV_SHAPE)
# Initialize individual ovv images for optical and sem stream
self.im_opt = copy.deepcopy(self.ovv_im)
self.im_sem = copy.deepcopy(self.ovv_im)
# Add stream to view
self.upd_stream = acqstream.RGBUpdatableStream("Overview Stream", self.ovv_im,
acq_type=MD_AT_OVV_TILES)
self.m_view.addStream(self.upd_stream)
def setUpClass(cls):
if driver.get_backend_status() == driver.BACKEND_RUNNING:
logging.info("A running backend is already found, skipping tests")
cls.backend_was_running = True
return
# run the backend as a daemon
# we cannot run it normally as the child would also think he's in a unittest
cmd = ODEMISD_CMD + ODEMISD_ARG + [SECOM_CONFIG]
ret = subprocess.call(cmd)
if ret != 0:
logging.error("Failed starting backend with '%s'", cmd)
time.sleep(1) # time to start
# create some streams connected to the backend
cls.microscope = model.getMicroscope()
for comp in model.getComponents():
if comp.role == "ccd":
cls.ccd = comp
elif comp.role == "spectrometer":
cls.spec = comp
elif comp.role == "e-beam":
cls.ebeam = comp
elif comp.role == "se-detector":
cls.sed = comp
elif comp.role == "light":
cls.light = comp
elif comp.role == "filter":
cls.light_filter = comp
s1 = stream.FluoStream("fluo1", cls.ccd, cls.ccd.data,
cls.light, cls.light_filter)
s2 = stream.FluoStream("fluo2", cls.ccd, cls.ccd.data,
cls.light, cls.light_filter)
s2.excitation.value = s2.excitation.range[1]
s3 = stream.BrightfieldStream("bf", cls.ccd, cls.ccd.data, cls.light)
cls.streams = [s1, s2, s3]
def __init__(self, main_data, tab, overview_canvas, m_view, stream_bar):
self.main_data = main_data
self._tab = tab
self._data_model = tab.tab_data_model
self.canvas = overview_canvas
self.m_view = m_view
self._stream_bar = stream_bar
self.conf = get_acqui_conf()
self.curr_s = None
# Timer to detect when the stage ends moving
self._timer_pos = wx.PyTimer(self.add_pos_to_history)
if hasattr(m_view, "merge_ratio"):
m_view.merge_ratio.subscribe(self._on_merge_ratio_change)
# Global overview image (Delphi)
if main_data.overview_ccd:
# Overview camera can be RGB => in that case len(shape) == 4
if len(main_data.overview_ccd.shape) == 4:
overview_stream = acqstream.RGBCameraStream(
"Overview",
main_data.overview_ccd,
main_data.overview_ccd.data,
None,
acq_type=MD_AT_OVV_FULL)
else:
overview_stream = acqstream.BrightfieldStream(
"Overview",
main_data.overview_ccd,
main_data.overview_ccd.data,
None,
acq_type=MD_AT_OVV_FULL)
self.m_view.addStream(overview_stream)
# TODO: add it to self.tab_data_model.streams?
else:
# black image to display history overlay separately from built-up ovv image
# controlled by merge slider
da, _ = self._initialize_ovv_im(OVV_SHAPE)
history_stream = acqstream.RGBUpdatableStream(
"History Stream", da, acq_type=MD_AT_HISTORY)
self.m_view.addStream(history_stream)
# Built-up overview image
self.ovv_im, self.m_view.mpp.value = self._initialize_ovv_im(OVV_SHAPE)
logging.debug("Overview image FoV: %s", getBoundingBox(self.ovv_im))
# Initialize individual ovv images for optical and sem stream
self.im_opt = copy.deepcopy(self.ovv_im)
self.im_sem = copy.deepcopy(self.ovv_im)
# Extra images to be used for complete overviews, shown behind the build-up images
self._bkg_opt = copy.deepcopy(self.ovv_im)
self._bkg_sem = copy.deepcopy(self.ovv_im)
# Add stream to view
self.upd_stream = acqstream.RGBUpdatableStream(
"Overview Stream", self.ovv_im, acq_type=MD_AT_OVV_TILES)
self.m_view.addStream(self.upd_stream)
self._data_model.focussedView.subscribe(self._on_focused_view)
if main_data.stage:
# Update the image when the stage move
main_data.stage.position.subscribe(self.on_stage_pos_change,
init=True)
main_data.chamberState.subscribe(self._on_chamber_state)
self._data_model.streams.subscribe(self._on_current_stream)
# Add a "acquire overview" button.
self._stream_bar.btn_add_overview.Bind(wx.EVT_BUTTON,
self._on_overview_acquire)
self._acquisition_controller = acqcont.OverviewStreamAcquiController(
self._data_model, tab)
self._bkg_ovv_subs = {
} # Just used temporarily when background overview is projected