Example #1
0
    def start(self):
        """
        Called when the menu entry is selected
        """
        main_data = self.main_app.main_data

        # Stop the streams
        tab_data = main_data.tab.value.tab_data_model
        for s in tab_data.streams.value:
            s.should_update.value = False

        self.filename.value = self._get_new_filename()
        self.dwellTime.value = main_data.ebeam.dwellTime.value
        self._update_exp_dur()

        if main_data.cld:
            # If the cl-detector is present => configure the optical path (just to speed-up)
            main_data.opm.setPath("cli")

        dlg = AcquisitionDialog(
            self, "Averaged acquisition",
            "Acquires the SEM and CL intensity streams multiple times, \n"
            "as defined by the 'accumulations' setting, \n"
            "and store the average value.")
        dlg.addSettings(self, self.vaconf)
        dlg.addButton("Close")
        dlg.addButton("Acquire", self.acquire, face_colour='blue')
        ans = dlg.ShowModal()

        if ans == 0:
            logging.info("Acquisition cancelled")
        elif ans == 1:
            logging.info("Acquisition completed")
        else:
            logging.warning("Got unknown return code %s", ans)
Example #2
0
    def start(self):
        # Check the acquisition tab is open, and a CL-intensity stream is available
        ct = self.main_app.main_data.tab.value
        cls = self._get_cl_intensity()
        if ct.name != "sparc_acqui" or not cls:
            logging.info("Failed to start RGB CL intensity stream")
            dlg = wx.MessageDialog(
                self.main_app.main_frame,
                "No CL-intensity stream is currently open.\n"
                "You need to open a CL intensity stream "
                "and set the acquisition parameters.\n",
                caption="RGB CL intensity",
                style=wx.OK | wx.ICON_WARNING)
            dlg.ShowModal()
            dlg.Destroy()
            return

        self._pause_streams()

        # immediately switch optical path, to save time
        self.main_app.main_data.opm.setPath(cls)  # non-blocking

        # Get survey stream too
        self._survey_s = self._get_sem_survey()
        self._cl_int_s = cls

        self._update_exp_dur()

        # Create a window
        dlg = AcquisitionDialog(
            self, "RGB CL intensity acquisition",
            "Acquires a RGB CL-intensity image\n"
            "Specify the relevant settings and start the acquisition\n")

        self.filename.value = self._get_new_filename()
        dlg.addSettings(self, conf=self.vaconf)
        dlg.addButton("Close")
        dlg.addButton("Acquire", self.acquire, face_colour='blue')

        # Show the window, and wait until the acquisition is over
        ans = dlg.ShowModal()

        # The window is closed
        if ans == 0:
            logging.debug("RGB CL intensity acquisition cancelled")
        elif ans == 1:
            logging.debug("RGB CL intensity acquisition completed")
        else:
            logging.warning("Unknown return code %d", ans)

        # Make sure we don't hold reference to the streams forever
        self._survey_s = None
        self._cl_int_s = None

        dlg.Destroy()
Example #3
0
    def start(self):
        if self.main_app.main_data.tab.value.name != "sparc_acqui":
            box = wx.MessageDialog(
                self.main_app.main_frame,
                "AR spectral acquisition must be done from the acquisition tab.",
                "AR spectral acquisition not possible", wx.OK | wx.ICON_STOP)
            box.ShowModal()
            box.Destroy()
            return

        # get region and dwelltime for drift correction
        self._ARspectral_s.dcRegion.value = self._tab_data.driftCorrector.roi.value
        self._ARspectral_s.dcDwellTime.value = self._tab_data.driftCorrector.dwellTime.value

        # Update the grating position to its current position
        self.grating.value = self.sgrh.position.value["grating"]

        # get survey
        self._survey_s = self._get_sem_survey()

        # For ROI:
        roi = self._tab_data.semStream.roi.value
        if roi == UNDEFINED_ROI:
            roi = (0, 0, 1, 1)
        self.roi.value = roi
        logging.debug("ROA = %s", self.roi.value)

        self._update_exp_dur()
        self._update_res()
        self._update_cam_res()

        # Create a window
        dlg = AcquisitionDialog(
            self, "AR Spectral acquisition",
            "Acquires a hyperspectral AR CL image\n"
            "Specify the relevant settings and start the acquisition\n")

        self.filename.value = self._get_new_filename()
        dlg.addSettings(self, conf=self.vaconf)
        dlg.addButton("Close")
        dlg.addButton("Acquire", self.acquire, face_colour='blue')

        # Show the window, and wait until the acquisition is over
        ans = dlg.ShowModal()

        # The window is closed
        if ans == 0:
            logging.info("AR spectral acquisition cancelled")
        elif ans == 1:
            logging.info("AR spectral acquisition completed")
        else:
            logging.debug("Unknown return code %d", ans)

        dlg.Destroy()
Example #4
0
    def start(self):
        # Error message if not in acquisition tab + spot mode
        ct = self.main_app.main_data.tab.value
        if (ct.name != "sparc_acqui"
                or ct.tab_data_model.tool.value != TOOL_SPOT
                or None in ct.tab_data_model.spotPosition.value):
            logging.info(
                "Failed to start monochromator scan as no spot is selected")
            dlg = wx.MessageDialog(
                self.main_app.main_frame, "No spot is currently selected.\n"
                "You need to select the point where the spectrum will be "
                "acquired with monochromator scan.\n",
                caption="Monochromator scan",
                style=wx.OK | wx.ICON_WARNING)
            dlg.ShowModal()
            dlg.Destroy()
            return

        self._survey_s = self._get_sem_survey()
        self._update_exp_dur()

        # Create a window
        dlg = AcquisitionDialog(
            self, "Monochromator scan acquisition",
            "Acquires a spectrum using the monochomator while scanning over "
            "multiple wavelengths.\n\n"
            "Specify the settings and start the acquisition.")

        self.filename.value = self._get_new_filename()
        dlg.addSettings(self, conf=self.vaconf)
        dlg.addButton("Close")
        dlg.addButton("Acquire", self.acquire, face_colour='blue')

        # Show the window, and wait until the acquisition is over
        ans = dlg.ShowModal()

        # Save the current folder
        conf = get_acqui_conf()
        conf.last_path = os.path.dirname(self.filename.value)

        # The window is closed
        if ans == 0:
            logging.info("Monochromator scan acquisition cancelled")
        elif ans == 1:
            logging.info("Monochromator scan acquisition completed")
        else:
            logging.debug("Unknown return code %d", ans)

        dlg.Destroy()
Example #5
0
    def start(self):
        """
        Called when the menu entry is selected
        """
        dlg = AcquisitionDialog(self, "SECOM user simulator",
                                "Simulates typical actions of a SECOM user.")
        dlg.addButton("FM search", self._sim_fluo_search, face_colour='blue')
        dlg.addButton("Stop", self._stop_sim)
        dlg.ShowModal() # Blocks until the user closes the window

        # make sure the simulation is stopped
        self._should_stop.set()

        if dlg: # If dlg hasn't been destroyed yet
            dlg.Destroy()
Example #6
0
    def start(self):
        dlg = AcquisitionDialog(self, "Manually change the alignment",
                                text="Change the translation, rotation, and pixel size "
                                     "of any stream. The display is immediately updated, "
                                     "but you need to save the file (as a snapshot) for "
                                     "the changes to be permanent.")
        vah = VAHolder()
        vah._subscribers = []
        vaconf = OrderedDict()

        tab_data = self.main_app.main_data.tab.value.tab_data_model
        for i, stream in enumerate(tab_data.streams.value):
            dlg.addStream(stream)

            # Add 5 VAs for each stream, to modify the overlay metadata
            poscor = stream.raw[0].metadata.get(model.MD_POS_COR, (0, 0))
            rotation = stream.raw[0].metadata.get(model.MD_ROTATION_COR, 0)
            scalecor = stream.raw[0].metadata.get(model.MD_PIXEL_SIZE_COR, (1, 1))
            vatransx = model.FloatContinuous(-poscor[0], range=(-10e-6, 10e-6), unit="m")
            vatransy = model.FloatContinuous(-poscor[1], range=(-10e-6, 10e-6), unit="m")
            varot = model.FloatContinuous(rotation, range=(-math.pi, math.pi), unit="rad")
            vascalex = model.FloatContinuous(scalecor[0], range=(0.5, 1.5))
            vascaley = model.FloatContinuous(scalecor[1], range=(0.5, 1.5))

            # Add the VAs to the holder, and to the vaconf mainly to force the order
            setattr(vah, "%dTransX" % i, vatransx)
            setattr(vah, "%dTransY" % i, vatransy)
            setattr(vah, "%dRotation" % i, varot)
            setattr(vah, "%dScaleX" % i, vascalex)
            setattr(vah, "%dScaleY" % i, vascaley)
            vaconf["%dTransX" % i] = {"label": "%s trans X" % stream.name.value}
            vaconf["%dTransY" % i] = {"label": "%s trans Y" % stream.name.value}
            vaconf["%dRotation" % i] = {"label": "%s rotation X" % stream.name.value}
            vaconf["%dScaleX" % i] = {"label": "%s scale X" % stream.name.value}
            vaconf["%dScaleY" % i] = {"label": "%s scale Y" % stream.name.value}

            # Create listeners with information of the stream and dimension
            va_on_transx = functools.partial(self._on_trans, stream, 0)
            va_on_transy = functools.partial(self._on_trans, stream, 1)
            va_on_rotation = functools.partial(self._on_rotation, stream)
            va_on_scalex = functools.partial(self._on_scale, stream, 0)
            va_on_scaley = functools.partial(self._on_scale, stream, 1)
            # We hold a reference to the listeners to prevent automatic subscription
            vah._subscribers.append(va_on_transx)
            vah._subscribers.append(va_on_transy)
            vah._subscribers.append(va_on_rotation)
            vah._subscribers.append(va_on_scalex)
            vah._subscribers.append(va_on_scaley)
            vatransx.subscribe(va_on_transx)
            vatransy.subscribe(va_on_transy)
            varot.subscribe(va_on_rotation)
            vascalex.subscribe(va_on_scalex)
            vascaley.subscribe(va_on_scaley)

        dlg.addSettings(vah, vaconf)
        # TODO: add a 'reset' button
        dlg.addButton("Done", None, face_colour='blue')
        dlg.ShowModal()
Example #7
0
    def start(self):
        """
        Called when the menu entry is selected
        """
        main_data = self.main_app.main_data

        # Stop the streams
        tab_data = main_data.tab.value.tab_data_model
        for s in tab_data.streams.value:
            s.should_update.value = False

        self.filename.value = self._get_new_filename()
        self._update_exp_dur()

        # Special CCD settings to get values as photon counting
        if model.hasVA(self.ccd, "countConvert"):
            self.ccd.countConvert.value = 2  # photons

        dlg = AcquisitionDialog(self, "Super-resolution acquisition",
                                "Acquires a series of shortly exposed images, "
                                "and store them in sequence.\n"
                                "Note, the advanced settings are only applied "
                                "after restarting the stream.")
        dlg.addStream(self._stream)
        dlg.addSettings(self, self.vaconf)
        dlg.addButton("Close")
        dlg.addButton("Acquire", self.acquire, face_colour='blue')
        dlg.Maximize()
        ans = dlg.ShowModal()

        # Make sure the stream is not playing anymore and CCD is back to normal
        self._stream.should_update.value = False
        if model.hasVA(self.ccd, "countConvert"):
            try:
                self.ccd.countConvert.value = 0  # normal
            except Exception:
                logging.exception("Failed to set back count convert mode")

        if ans == 0:
            logging.info("Acquisition cancelled")
        elif ans == 1:
            logging.info("Acquisition completed")
        else:
            logging.warning("Got unknown return code %s", ans)

        dlg.Destroy()
Example #8
0
    def start(self):
        # get region and dwelltime for drift correction
        self._correlator_s.dcRegion.value = self._acqui_tab.driftCorrector.roi.value
        self._correlator_s.dcDwellTime.value = self._acqui_tab.driftCorrector.dwellTime.value

        # get survey
        self._survey_s = self._get_sem_survey()

        # For ROI:
        roi = self._acqui_tab.semStream.roi.value
        if roi == UNDEFINED_ROI:
            roi = (0, 0, 1, 1)
        self.roi.value = roi
        logging.debug("ROA = %s", self.roi.value)

        self._update_exp_dur()
        self._update_res()

        # Create a window
        dlg = AcquisitionDialog(
            self, "Time correlator acquisition",
            "Acquires a scan using the time correlator\n"
            "Specify the relevant settings and start the acquisition\n")

        self.filename.value = self._get_new_filename()
        dlg.addSettings(self, conf=self.vaconf)
        dlg.addButton("Close")
        dlg.addButton("Acquire", self.acquire, face_colour='blue')

        # Show the window, and wait until the acquisition is over
        ans = dlg.ShowModal()

        # The window is closed
        if ans == 0:
            logging.info("Correlator acquisition cancelled")
        elif ans == 1:
            logging.info("Correlator acquisition completed")
        else:
            logging.debug("Unknown return code %d", ans)

        dlg.Destroy()
Example #9
0
    def start(self):
        self.filename.value = self._get_new_filename()
        self._update_stepsize()

        dlg = AcquisitionDialog(
            self, "CL acquisition",
            "Acquires a CCD image for each e-beam spot.\n")
        dlg.addSettings(self, self.vaconf)
        # dlg.addStream(self._get_sem_survey) # TODO: add survey + ROI selection tool
        dlg.addButton("Cancel")
        dlg.addButton("Acquire", self._acquire, face_colour='blue')
        ans = dlg.ShowModal()

        if ans == 0:
            logging.info("Acquisition cancelled")
        elif ans == 1:
            logging.info("Acquisition completed")
        else:
            logging.warning("Got unknown return code %s", ans)

        dlg.Destroy()
Example #10
0
    def start(self):
        """
        Called when the menu entry is selected
        """
        dlg = AcquisitionDialog(self, "SECOM user simulator",
                                "Simulates typical actions of a SECOM user.")
        dlg.addButton("FM search", self._sim_fluo_search, face_colour='blue')
        dlg.addButton("Stop", self._stop_sim)
        dlg.ShowModal()  # Blocks until the user closes the window

        # make sure the simulation is stopped
        self._should_stop.set()

        if dlg:  # If dlg hasn't been destroyed yet
            dlg.Destroy()
Example #11
0
    def start(self, st):
        self._stream = st
        self.filename.value = self._get_new_filename()

        dlg = AcquisitionDialog(self, "Timelapse acquisition",
                                "The same stream will be acquired multiple times, defined by the 'number of acquisitions'.\n"
                                "The time separating each acquisition is defined by the 'period'.\n")
        dlg.addSettings(self, self.vaconf)
        dlg.addStream(st)
        dlg.addButton("Cancel")
        dlg.addButton("Acquire", self.acquire, face_colour='blue')
        ans = dlg.ShowModal()

        if ans == 0:
            logging.info("Acquisition cancelled")
        elif ans == 1:
            logging.info("Acquisition completed")
        else:
            logging.warning("Got unknown return code %s", ans)
Example #12
0
    def start(self):
        # Check the acquisition tab is open, and a CL-intensity stream is available
        ct = self.main_app.main_data.tab.value
        cls = self._get_cl_intensity()
        if ct.name != "sparc_acqui" or not cls:
            logging.info("Failed to start RGB CL intensity stream")
            dlg = wx.MessageDialog(self.main_app.main_frame,
                                   "No CL-intensity stream is currently open.\n"
                                   "You need to open a CL intensity stream "
                                   "and set the acquisition parameters.\n",
                                   caption="RGB CL intensity",
                                   style=wx.OK | wx.ICON_WARNING)
            dlg.ShowModal()
            dlg.Destroy()
            return

        self._pause_streams()

        # immediately switch optical path, to save time
        self.main_app.main_data.opm.setPath(cls)  # non-blocking

        # Get survey stream too
        self._survey_s = self._get_sem_survey()
        self._cl_int_s = cls

        self._update_exp_dur()

        # Create a window
        dlg = AcquisitionDialog(self, "RGB CL intensity acquisition",
                                "Acquires a RGB CL-intensity image\n"
                                "Specify the relevant settings and start the acquisition\n"
                                )

        self.filename.value = self._get_new_filename()
        dlg.addSettings(self, conf=self.vaconf)
        dlg.addButton("Close")
        dlg.addButton("Acquire", self.acquire, face_colour='blue')

        # Show the window, and wait until the acquisition is over
        ans = dlg.ShowModal()

        # The window is closed
        if ans == 0:
            logging.debug("RGB CL intensity acquisition cancelled")
        elif ans == 1:
            logging.debug("RGB CL intensity acquisition completed")
        else:
            logging.warning("Unknown return code %d", ans)

        dlg.Destroy()
Example #13
0
    def start(self):
        # Error message if not in acquisition tab + spot mode
        ct = self.main_app.main_data.tab.value
        if (
            ct.name != "sparc_acqui"
            or ct.tab_data_model.tool.value != TOOL_SPOT
            or None in ct.tab_data_model.spotPosition.value
        ):
            logging.info("Failed to start monochromator scan as no spot is selected")
            dlg = wx.MessageDialog(
                self.main_app.main_frame,
                "No spot is currently selected.\n"
                "You need to select the point where the spectrum will be "
                "acquired with monochromator scan.\n",
                caption="Monochromator scan",
                style=wx.OK | wx.ICON_WARNING,
            )
            dlg.ShowModal()
            dlg.Destroy()
            return

        self._survey_s = self._get_sem_survey()
        self._update_exp_dur()

        # Create a window
        dlg = AcquisitionDialog(
            self,
            "Monochromator scan acquisition",
            "Acquires a spectrum using the monochomator while scanning over "
            "multiple wavelengths.\n\n"
            "Specify the settings and start the acquisition.",
        )

        self.filename.value = self._get_new_filename()
        dlg.addSettings(self, conf=self.vaconf)
        dlg.addButton("Close")
        dlg.addButton("Acquire", self.acquire, face_colour="blue")

        # Show the window, and wait until the acquisition is over
        ans = dlg.ShowModal()

        # The window is closed
        if ans == 0:
            logging.info("Monochromator scan acquisition cancelled")
        elif ans == 1:
            logging.info("Monochromator scan acquisition completed")
        else:
            logging.debug("Unknown return code %d", ans)
Example #14
0
    def start(self):
        # get region and dwelltime for drift correction
        self._ARspectral_s.dcRegion.value = self._acqui_tab.driftCorrector.roi.value
        self._ARspectral_s.dcDwellTime.value = self._acqui_tab.driftCorrector.dwellTime.value

        # Update the grating position to its current position
        self.grating.value = self.sgrh.position.value["grating"]

        # get survey
        self._survey_s = self._get_sem_survey()

        # For ROI:
        roi = self._acqui_tab.semStream.roi.value
        if roi == UNDEFINED_ROI:
            roi = (0, 0, 1, 1)
        self.roi.value = roi
        logging.debug("ROA = %s", self.roi.value)

        self._update_exp_dur()
        self._update_res()
        self._update_cam_res()

        # Create a window
        dlg = AcquisitionDialog(self, "AR Spectral acquisition",
                                "Acquires a hyperspectral AR CL image\n"
                                "Specify the relevant settings and start the acquisition\n"
                                )

        self.filename.value = self._get_new_filename()
        dlg.addSettings(self, conf=self.vaconf)
        dlg.addButton("Close")
        dlg.addButton("Acquire", self.acquire, face_colour='blue')

        # Show the window, and wait until the acquisition is over
        ans = dlg.ShowModal()

        # The window is closed
        if ans == 0:
            logging.info("AR spectral acquisition cancelled")
        elif ans == 1:
            logging.info("AR spectral acquisition completed")
        else:
            logging.debug("Unknown return code %d", ans)

        dlg.Destroy()
Example #15
0
    def start(self):
        self.filename.value = self._get_new_filename()
        self._update_stepsize(None)

        dlg = AcquisitionDialog(self, "CL acquisition",
                                "Acquires a CCD image for each e-beam spot.\n")
        dlg.addSettings(self, self.vaconf)
        # dlg.addStream(self._get_sem_survey) # TODO: add survey + ROI selection tool
        dlg.addButton("Cancel")
        dlg.addButton("Acquire", self._acquire, face_colour='blue')
        ans = dlg.ShowModal()

        if ans == 0:
            logging.info("Acquisition cancelled")
        elif ans == 1:
            logging.info("Acquisition completed")
        else:
            logging.warning("Got unknown return code %s", ans)
Example #16
0
    def start(self):
        """
        Called when the menu entry is selected
        """
        main_data = self.main_app.main_data

        # Stop the streams
        tab_data = main_data.tab.value.tab_data_model
        for s in tab_data.streams.value:
            s.should_update.value = False

        self.filename.value = self._get_new_filename()
        self.dwellTime.value = main_data.ebeam.dwellTime.value
        self._update_exp_dur()

        if main_data.cld:
            # If the cl-detector is present => configure the optical path (just to speed-up)
            main_data.opm.setPath("cli")

        dlg = AcquisitionDialog(self, "Averaged acquisition",
                    "Acquires the SEM and CL intensity streams multiple times, \n"
                    "as defined by the 'accumulations' setting, \n"
                    "and store the average value.")
        dlg.addSettings(self, self.vaconf)
        dlg.addButton("Close")
        dlg.addButton("Acquire", self.acquire, face_colour='blue')
        ans = dlg.ShowModal()

        if ans == 0:
            logging.info("Acquisition cancelled")
        elif ans == 1:
            logging.info("Acquisition completed")
        else:
            logging.warning("Got unknown return code %s", ans)

        dlg.Destroy()
Example #17
0
    def start(self):
        dlg = AcquisitionDialog(self, "Fancy Acquisition", "Enter everything")
        dlg.addSettings(self,
                        conf={"filename": {
                            "control_type": CONTROL_SAVE_FILE
                        }})
        dlg.addButton("Cancel")
        dlg.addButton("Acquire", self.acquire, face_colour='blue')

        stream = FakeFluoStream("Fluo Stream")
        dlg.addStream(stream)
        stream = FakeFluoStream("Fluo Stream")
        dlg.addStream(stream)

        ans = dlg.ShowModal()

        if ans == 1:
            # Ignore errors about a missing analysis tab
            try:
                self.showAcquisition(self.filename.value)
            except AttributeError:
                pass
Example #18
0
    def start(self):
        """
        Called when the menu entry is selected
        """
        main_data = self.main_app.main_data

        # Stop the streams
        tab_data = main_data.tab.value.tab_data_model
        for s in tab_data.streams.value:
            s.should_update.value = False

        self.filename.value = self._get_new_filename()
        self._update_exp_dur()

        # Special CCD settings to get values as photon counting
        if model.hasVA(self.ccd, "countConvert"):
            self.ccd.countConvert.value = 2  # photons

        dlg = AcquisitionDialog(self, "Super-resolution acquisition",
                                "Acquires a series of shortly exposed images, "
                                "and store them in sequence.\n"
                                "Note, the advanced settings are only applied "
                                "after restarting the stream.")
        dlg.addStream(self._stream)
        dlg.addSettings(self, self.vaconf)
        dlg.addButton("Close")
        dlg.addButton("Acquire", self.acquire, face_colour='blue')
        dlg.Maximize()
        ans = dlg.ShowModal()

        # Make sure the stream is not playing anymore and CCD is back to normal
        self._stream.should_update.value = False
        if model.hasVA(self.ccd, "countConvert"):
            try:
                self.ccd.countConvert.value = 0  # normal
            except Exception:
                logging.exception("Failed to set back count convert mode")

        if ans == 0:
            logging.info("Acquisition cancelled")
        elif ans == 1:
            logging.info("Acquisition completed")
        else:
            logging.warning("Got unknown return code %s", ans)

        dlg.Destroy()
Example #19
0
    def start(self):
        # Fail if the live tab is not selected
        tab = self.main_app.main_data.tab.value
        if tab.name not in ("secom_live", "sparc_acqui", "cryosecom-localization"):
            box = wx.MessageDialog(self.main_app.main_frame,
                       "ZStack acquisition must be done from the acquisition stream.",
                       "ZStack acquisition not possible", wx.OK | wx.ICON_STOP)
            box.ShowModal()
            box.Destroy()
            return

        # On SPARC, fail if no ROI selected
        if hasattr(tab.tab_data_model, "roa") and tab.tab_data_model.roa.value == UNDEFINED_ROI:
            box = wx.MessageDialog(self.main_app.main_frame,
                       "You need to select a region of acquisition.",
                       "Z stack acquisition not possible", wx.OK | wx.ICON_STOP)
            box.ShowModal()
            box.Destroy()
            return

        # Stop the stream(s) playing to not interfere with the acquisition
        tab.streambar_controller.pauseStreams()

        self.filename.value = self._get_new_filename()
        dlg = AcquisitionDialog(self, "Z Stack acquisition",
                                "The same streams will be acquired multiple times at different Z positions, defined starting from Z start, with a step size.\n")
        self._dlg = dlg
        dlg.addSettings(self, self.vaconf)
        ss = self._get_live_streams(tab.tab_data_model)
        for s in ss:
            if isinstance(s, (ARStream, SpectrumStream, MonochromatorSettingsStream)):
                # TODO: instead of hard-coding the list, a way to detect the type
                # of live image?
                logging.info("Not showing stream %s, for which the live image is not spatial", s)
                dlg.addStream(s, index=None)
            else:
                dlg.addStream(s)
        dlg.addButton("Cancel")
        dlg.addButton("Acquire", self.acquire, face_colour='blue')

        # Connect zstart with the actual focus position
        self.zstart.subscribe(self._on_zstart)
        self.focus.position.subscribe(self._on_focus_pos, init=True)

        # Update acq time when streams are added/removed
        dlg.view.stream_tree.flat.subscribe(self._update_exp_dur, init=True)
        dlg.hidden_view.stream_tree.flat.subscribe(self._update_exp_dur, init=True)
        # TODO: update the acquisition time whenever a setting changes

        # TODO: disable "acquire" button if no stream selected

        # TODO: also display the repetition and axis settings for the SPARC streams.

        ans = dlg.ShowModal()

        if ans == 0:
            logging.info("Acquisition cancelled")
        elif ans == 1:
            logging.info("Acquisition completed")
        else:
            logging.warning("Got unknown return code %s", ans)

        self.focus.position.unsubscribe(self._on_focus_pos)
        self.zstart.unsubscribe(self._on_zstart)

        # Don't hold references
        self._acq_streams = None
        if dlg:  # If dlg hasn't been destroyed yet
            dlg.Destroy()
Example #20
0
    def start(self):
        dlg = AcquisitionDialog(self, "Remove spikes from CL data",
                                text="Change the threshold value to determine the sensitivity of the spike removal")
        self._dlg = dlg
        self.tab_data = self.main_app.main_data.tab.value.tab_data_model

        # don't allow adding/removing streams
        dlg.streambar_controller.to_static_mode()

        for stream in self.tab_data.streams.value:
            #there must be a better way to do this
            if isinstance(stream, SpectrumStream):
                # Check the stream is really _spectrum_ data, CTYX or TYX are not supported
                raw_shape = stream.raw[0].shape  # CTZYX
                if numpy.prod(raw_shape[1:3]) > 1:  # T * Z
                    logging.info("Skipping stream %s of shape %s, as it not a simple spectral stream",
                                 stream.name, raw_shape)
                    continue
                dlg.addStream(stream)
                self._spec_stream = stream
                break  # Only one stream handled
        else:
            # if no spectral data is present spike removal cannot be done (for now)
            box = wx.MessageDialog(self.main_app.main_frame,
                   "No spectral stream is present, so it's not possible to correct the data",
                   "No spectral stream", wx.OK | wx.ICON_STOP)
            box.ShowModal()
            box.Destroy()
            return

        wx.CallAfter(dlg.viewport_l.canvas.fit_view_to_content)  # async, to call after the stream is added
        dlg.addSettings(self, conf=self.vaconf)
        # TODO: add a 'reset' button
        dlg.addButton("Close")
        dlg.addButton("Correct", self.correct_data, face_colour='red')
        dlg.addButton("Save", self.save, face_colour='blue')
        self._update_save_button()  # It'll be called _after_ the button is added

        dlg.Size = (1000, 600)  # Make it big enough to fit the view and the stream panel
        dlg.ShowModal()

        # The end
        self._spec_stream = None  # drop reference
        dlg.Close()
        self._dlg = None
        
        if dlg: # If dlg hasn't been destroyed yet
            dlg.Destroy()
Example #21
0
    def start(self):
        dlg = AcquisitionDialog(
            self,
            "Merging channels to RGB image",
            text="Insert 3 R, G, B files so that they are assigned the tints \n"
            "and are merged to an RGB image.")
        # remove the play overlay from the viewport
        dlg.viewport_l.canvas.remove_view_overlay(
            dlg.viewport_l.canvas.play_overlay)

        self._dlg = dlg
        dlg.addStream(None)
        dlg.Size = (1000, 600)

        dlg.addSettings(self, self.vaconf)
        dlg.addButton("Cancel", None)
        dlg.addButton("Add", self._updateViewer, face_colour='blue')

        dlg.pnl_gauge.Hide()
        dlg.ShowModal()  # Blocks until the window is closed

        # Destroy the dialog and reset the VAs and subscribers
        dlg.Destroy()
        self.filenameR.value = " "
        self.filenameG.value = " "
        self.filenameB.value = " "
        self.redShiftX.value = 0
        self.redShiftY.value = 0
        self.greenShiftX.value = 0
        self.greenShiftY.value = 0
        self.blueShiftX.value = 0
        self.blueShiftY.value = 0
        self.cropBottom.value = 0
        self._subscribers = []
        self._dlg = None
        self._raw_orig = {}
Example #22
0
    def show_dlg(self):
        # TODO: if there is a chamber, only allow if there is vacuum

        # Fail if the live tab is not selected
        self._tab = self.main_app.main_data.tab.value
        if self._tab.name not in ("secom_live", "sparc_acqui"):
            box = wx.MessageDialog(self.main_app.main_frame,
                       "Tiled acquisition must be done from the acquisition stream.",
                       "Tiled acquisition not possible", wx.OK | wx.ICON_STOP)
            box.ShowModal()
            box.Destroy()
            return

        self._tab.streambar_controller.pauseStreams()

        # If no ROI is selected, select entire area
        try:
            if self._tab.tab_data_model.semStream.roi.value == UNDEFINED_ROI:
                self._tab.tab_data_model.semStream.roi.value = (0, 0, 1, 1)
        except AttributeError:
            pass  # Not a SPARC

        # Disable drift correction (on SPARC)
        if hasattr(self._tab.tab_data_model, "driftCorrector"):
            self._tab.tab_data_model.driftCorrector.roi.value = UNDEFINED_ROI

        ss = self._get_live_streams()
        self.filename.value = self._get_new_filename()

        dlg = AcquisitionDialog(self, "Tiled acquisition",
                                "Acquire a large area by acquiring the streams multiple "
                                "times over a grid.")
        self._dlg = dlg
        # don't allow adding/removing streams
        self._dlg.streambar_controller.to_static_mode()

        dlg.addSettings(self, self.vaconf)
        for s in ss:
            if isinstance(s, (ARStream, SpectrumStream, MonochromatorSettingsStream)):
                # TODO: instead of hard-coding the list, a way to detect the type
                # of live image?
                logging.info("Not showing stream %s, for which the live image is not spatial", s)
                dlg.addStream(s, index=None)
            else:
                dlg.addStream(s, index=0)

        dlg.addButton("Cancel")
        dlg.addButton("Acquire", self.acquire, face_colour='blue')

        # Update acq time and area when streams are added/removed. Add stream settings
        # to subscribed vas.
        dlg.view.stream_tree.flat.subscribe(self._update_exp_dur, init=True)
        dlg.view.stream_tree.flat.subscribe(self._update_total_area, init=True)
        dlg.view.stream_tree.flat.subscribe(self._on_streams_change, init=True)

        # Default fineAlign to True if it's possible
        # Use live streams to make the decision since visible streams might not be initialized yet
        # TODO: the visibility of the streams seems to be reset when the plugin is started,
        # a stream that is invisible in the main panel becomes visible. This should be fixed.
        if self._can_fine_align(ss):
            self.fineAlign.value = True
            self._ovrl_stream = self._create_overlay_stream(ss)

        # This looks tautologic, but actually, it forces the setter to check the
        # value is within range, and will automatically reduce it if necessary.
        self.nx.value = self.nx.value
        self.ny.value = self.ny.value
        self._memory_check()

        # TODO: disable "acquire" button if no stream selected.

        ans = dlg.ShowModal()
        if ans == 0 or ans == wx.ID_CANCEL:
            logging.info("Tiled acquisition cancelled")
            self.ft.cancel()
        elif ans == 1:
            logging.info("Tiled acquisition completed")
        else:
            logging.warning("Got unknown return code %s", ans)

        # Don't hold references
        self._unsubscribe_vas()
        dlg.Destroy()
        self._dlg = None
Example #23
0
    def start(self):
        dlg = AcquisitionDialog(self, "Fancy Acquisition", "Enter everything")
        dlg.addSettings(self, conf={"filename": {"control_type": CONTROL_SAVE_FILE}})
        dlg.addButton("Cancel")
        dlg.addButton("Acquire", self.acquire, face_colour='blue')

        stream = FakeFluoStream("Fluo Stream")
        dlg.addStream(stream)
        stream = FakeFluoStream("Fluo Stream")
        dlg.addStream(stream)

        ans = dlg.ShowModal()

        if ans == 0:
            # Ignore errors about a missing analysis tab
            try:
                self.showAcquisition(self.filename.value)
            except AttributeError:
                pass
Example #24
0
    def show_dlg(self):
        # TODO: if there is a chamber, only allow if there is vacuum

        # Fail if the live tab is not selected
        self._tab = self.main_app.main_data.tab.value
        if self._tab.name not in ("secom_live", "sparc_acqui"):
            box = wx.MessageDialog(
                self.main_app.main_frame,
                "Tiled acquisition must be done from the acquisition tab.",
                "Tiled acquisition not possible", wx.OK | wx.ICON_STOP)
            box.ShowModal()
            box.Destroy()
            return

        self._tab.streambar_controller.pauseStreams()

        # If no ROI is selected, select entire area
        try:
            if self._tab.tab_data_model.semStream.roi.value == UNDEFINED_ROI:
                self._tab.tab_data_model.semStream.roi.value = (0, 0, 1, 1)
        except AttributeError:
            pass  # Not a SPARC

        # Disable drift correction (on SPARC)
        if hasattr(self._tab.tab_data_model, "driftCorrector"):
            self._tab.tab_data_model.driftCorrector.roi.value = UNDEFINED_ROI

        ss = self._get_live_streams()
        self.filename.value = self._get_new_filename()

        dlg = AcquisitionDialog(
            self, "Tiled acquisition",
            "Acquire a large area by acquiring the streams multiple "
            "times over a grid.")
        self._dlg = dlg
        # don't allow adding/removing streams
        self._dlg.streambar_controller.to_static_mode()

        dlg.addSettings(self, self.vaconf)
        for s in ss:
            if isinstance(
                    s,
                (ARStream, SpectrumStream, MonochromatorSettingsStream)):
                # TODO: instead of hard-coding the list, a way to detect the type
                # of live image?
                logging.info(
                    "Not showing stream %s, for which the live image is not spatial",
                    s)
                dlg.addStream(s, index=None)
            else:
                dlg.addStream(s, index=0)

        dlg.addButton("Cancel")
        dlg.addButton("Acquire", self.acquire, face_colour='blue')

        # Update acq time and area when streams are added/removed. Add stream settings
        # to subscribed vas.
        dlg.view.stream_tree.flat.subscribe(self._update_exp_dur, init=True)
        dlg.view.stream_tree.flat.subscribe(self._update_total_area, init=True)
        dlg.view.stream_tree.flat.subscribe(self._on_streams_change, init=True)

        # Default fineAlign to True if it's possible
        # Use live streams to make the decision since visible streams might not be initialized yet
        # TODO: the visibility of the streams seems to be reset when the plugin is started,
        # a stream that is invisible in the main panel becomes visible. This should be fixed.
        if self._can_fine_align(ss):
            self.fineAlign.value = True
            self._ovrl_stream = self._create_overlay_stream(ss)

        # This looks tautologic, but actually, it forces the setter to check the
        # value is within range, and will automatically reduce it if necessary.
        self.nx.value = self.nx.value
        self.ny.value = self.ny.value
        self._memory_check()

        # TODO: disable "acquire" button if no stream selected.

        ans = dlg.ShowModal()
        if ans == 0 or ans == wx.ID_CANCEL:
            logging.info("Tiled acquisition cancelled")
            self.ft.cancel()
        elif ans == 1:
            logging.info("Tiled acquisition completed")
        else:
            logging.warning("Got unknown return code %s", ans)

        # Don't hold references
        self._unsubscribe_vas()
        dlg.Destroy()
        self._dlg = None
Example #25
0
    def start(self):
        dlg = AcquisitionDialog(
            self,
            "Manually change the alignment",
            text="Change the translation, rotation, and pixel size "
            "of any stream. The display is immediately updated, "
            "but you need to save the file (as a snapshot) for "
            "the changes to be permanent.")
        self._dlg = dlg

        vah = VAHolder()
        vah._subscribers = []
        vaconf = OrderedDict()

        tab_data = self.main_app.main_data.tab.value.tab_data_model
        if not tab_data.streams.value:
            box = wx.MessageDialog(
                self.main_app.main_frame,
                "No stream is present, so it's not possible to modify the alignment.",
                "No stream", wx.OK | wx.ICON_STOP)
            box.ShowModal()
            box.Destroy()
            return

        for i, stream in enumerate(tab_data.streams.value):
            dlg.addStream(stream)

            # Add 5 VAs for each stream, to modify the overlay metadata
            poscor = stream.raw[0].metadata.get(model.MD_POS_COR, (0, 0))
            rotation = stream.raw[0].metadata.get(model.MD_ROTATION_COR, 0)
            scalecor = stream.raw[0].metadata.get(model.MD_PIXEL_SIZE_COR,
                                                  (1, 1))
            shear = stream.raw[0].metadata.get(model.MD_SHEAR_COR, 0)
            vatransx = model.FloatContinuous(-poscor[0],
                                             range=(-10e-6, 10e-6),
                                             unit="m")
            vatransy = model.FloatContinuous(-poscor[1],
                                             range=(-10e-6, 10e-6),
                                             unit="m")
            varot = model.FloatContinuous(rotation,
                                          range=(-math.pi, math.pi),
                                          unit="rad")
            vascalex = model.FloatContinuous(scalecor[0], range=(0.5, 1.5))
            vascaley = model.FloatContinuous(scalecor[1], range=(0.5, 1.5))
            vashear = model.FloatContinuous(shear, range=(-1, 1))

            # Add the VAs to the holder, and to the vaconf mainly to force the order
            setattr(vah, "%dTransX" % i, vatransx)
            setattr(vah, "%dTransY" % i, vatransy)
            setattr(vah, "%dRotation" % i, varot)
            setattr(vah, "%dScaleX" % i, vascalex)
            setattr(vah, "%dScaleY" % i, vascaley)
            setattr(vah, "%dShear" % i, vashear)
            vaconf["%dTransX" % i] = {
                "label": "%s trans X" % stream.name.value
            }
            vaconf["%dTransY" % i] = {
                "label": "%s trans Y" % stream.name.value
            }
            vaconf["%dRotation" % i] = {
                "label": "%s rotation" % stream.name.value
            }
            vaconf["%dScaleX" % i] = {
                "label": "%s scale X" % stream.name.value
            }
            vaconf["%dScaleY" % i] = {
                "label": "%s scale Y" % stream.name.value
            }
            vaconf["%dShear" % i] = {"label": "%s shear" % stream.name.value}

            # Create listeners with information of the stream and dimension
            va_on_transx = functools.partial(self._on_trans, stream, 0)
            va_on_transy = functools.partial(self._on_trans, stream, 1)
            va_on_rotation = functools.partial(self._on_rotation, stream)
            va_on_scalex = functools.partial(self._on_scale, stream, 0)
            va_on_scaley = functools.partial(self._on_scale, stream, 1)
            va_on_shear = functools.partial(self._on_shear, stream)

            # We hold a reference to the listeners to prevent automatic subscription
            vah._subscribers.append(va_on_transx)
            vah._subscribers.append(va_on_transy)
            vah._subscribers.append(va_on_rotation)
            vah._subscribers.append(va_on_scalex)
            vah._subscribers.append(va_on_scaley)
            vah._subscribers.append(va_on_shear)
            vatransx.subscribe(va_on_transx)
            vatransy.subscribe(va_on_transy)
            varot.subscribe(va_on_rotation)
            vascalex.subscribe(va_on_scalex)
            vascaley.subscribe(va_on_scaley)
            vashear.subscribe(va_on_shear)

        dlg.addSettings(vah, vaconf)
        # TODO: add a 'reset' button
        dlg.addButton("Done", None, face_colour='blue')
        dlg.ShowModal()

        # The end
        dlg.Destroy()
        vah._subscribers = []
        self._dlg = None
Example #26
0
    def start(self):
        # Fail if the live tab is not selected
        tab = self.main_app.main_data.tab.value
        if tab.name not in ("secom_live", "sparc_acqui"):
            box = wx.MessageDialog(self.main_app.main_frame,
                       "ZStack acquisition must be done from the acquisition stream.",
                       "ZStack acquisition not possible", wx.OK | wx.ICON_STOP)
            box.ShowModal()
            box.Destroy()
            return

        # On SPARC, fail if no ROI selected
        if hasattr(tab.tab_data_model, "roa") and tab.tab_data_model.roa.value == UNDEFINED_ROI:
            box = wx.MessageDialog(self.main_app.main_frame,
                       "You need to select a region of acquisition.",
                       "Z stack acquisition not possible", wx.OK | wx.ICON_STOP)
            box.ShowModal()
            box.Destroy()
            return

        # Stop the stream(s) playing to not interfere with the acquisition
        tab.streambar_controller.pauseStreams()

        self.filename.value = self._get_new_filename()
        dlg = AcquisitionDialog(self, "Z Stack acquisition",
                                "The same streams will be acquired multiple times at different Z positions, defined starting from Z start, with a step size.\n")
        self._dlg = dlg
        dlg.addSettings(self, self.vaconf)
        ss = self._get_live_streams(tab.tab_data_model)
        for s in ss:
            if isinstance(s, (ARStream, SpectrumStream, MonochromatorSettingsStream)):
                # TODO: instead of hard-coding the list, a way to detect the type
                # of live image?
                logging.info("Not showing stream %s, for which the live image is not spatial", s)
                dlg.addStream(s, index=None)
            else:
                dlg.addStream(s)
        dlg.addButton("Cancel")
        dlg.addButton("Acquire", self.acquire, face_colour='blue')

        # Update acq time when streams are added/removed
        dlg.view.stream_tree.flat.subscribe(self._update_exp_dur, init=True)
        dlg.hidden_view.stream_tree.flat.subscribe(self._update_exp_dur, init=True)
        # TODO: update the acquisition time whenever a setting changes

        # TODO: disable "acquire" button if no stream selected

        # TODO: also display the repetition and axis settings for the SPARC streams.

        ans = dlg.ShowModal()

        if ans == 0:
            logging.info("Acquisition cancelled")
        elif ans == 1:
            logging.info("Acquisition completed")
        else:
            logging.warning("Got unknown return code %s", ans)

        # Don't hold references
        self._acq_streams = None
        if dlg:  # If dlg hasn't been destroyed yet
            dlg.Destroy()
Example #27
0
    def start(self):
        """
        Displays the plugin window.
        """
        self._update_filename()
        str_ctrl = self.main_app.main_data.tab.value.streambar_controller
        str_ctrl.pauseStreams()

        dlg = AcquisitionDialog(
            self, "CL acquisition",
            "Acquires a CCD image for each e-beam spot.\n")
        self._dlg = dlg
        self._survey_stream = self._get_sem_survey()

        dlg.SetSize((1500, 1000))

        # Hack to force the canvas to have a region of acquisition (ROA) and anchor region (drift) overlay.
        dlg._dmodel.tool.choices = {
            TOOL_NONE,
            TOOL_ROA,
            TOOL_RO_ANCHOR,
        }

        dlg._dmodel.roa = self._secom_cl_stream.roi  # region of acquisition selected (x_tl, y_tl, x_br, y_br)
        dlg._dmodel.fovComp = self.main_data.ebeam  # size (x, y) of sem image for given magnification
        dlg._dmodel.driftCorrector = self._driftCorrector
        dlg.viewport_l.canvas.view = None
        dlg.viewport_l.canvas.setView(dlg.view, dlg._dmodel)
        dlg.viewport_r.canvas.allowed_modes = {}
        dlg.viewport_r.canvas.view = None
        dlg.viewport_r.canvas.setView(dlg.view_r, dlg._dmodel)

        self.repetition = self._secom_cl_stream.repetition  # ebeam positions to acquire
        self.repetition.subscribe(self._on_rep, init=True)
        self.pixelSize = self._secom_cl_stream.pixelSize  # pixel size per ebeam pos
        self.roi_margin = self._secom_cl_stream.roi_margin
        self.period = self._driftCorrector.period  # time between to drift corrections
        self.tool = dlg._dmodel.tool  # tools to select ROA and anchor region for drift correction
        self._driftCorrector.roi.subscribe(self._on_dc_roi, init=True)

        # subscribe to update estimated acquisition time
        self.repetition.subscribe(self._update_exp_dur, init=True)
        self.period.subscribe(self._update_exp_dur)
        self._driftCorrector.roi.subscribe(self._update_exp_dur)

        dlg.addSettings(self, self.vaconf)
        dlg.addStream(self._survey_stream)
        dlg.addStream(self._optical_stream)

        dlg.addButton("Cancel")
        dlg.addButton("Acquire", self._acquire, face_colour='blue')

        ans = dlg.ShowModal()

        if ans == 0:
            logging.info("Acquisition cancelled")
        elif ans == 1:
            logging.info("Acquisition completed")
        else:
            logging.warning("Got unknown return code %s", ans)

        self._dlg = None
        self._survey_stream = None
        dlg.Destroy()
Example #28
0
    def start(self):
        # Fail if the live tab is not selected
        tab = self.main_app.main_data.tab.value
        if tab.name not in ("secom_live", "sparc_acqui"):
            box = wx.MessageDialog(
                self.main_app.main_frame,
                "Timelapse acquisition must be done from the acquisition stream.",
                "Timelapse acquisition not possible", wx.OK | wx.ICON_STOP)
            box.ShowModal()
            box.Destroy()
            return

        # On SPARC, fail if no ROI selected
        try:
            if tab.tab_data_model.semStream.roi.value == UNDEFINED_ROI:
                box = wx.MessageDialog(
                    self.main_app.main_frame,
                    "You need to select a region of acquisition.",
                    "Timelapse acquisition not possible", wx.OK | wx.ICON_STOP)
                box.ShowModal()
                box.Destroy()
                return
        except AttributeError:
            pass  # Not a SPARC

        # Stop the stream(s) playing to not interfere with the acquisition
        tab.streambar_controller.pauseStreams()

        self.filename.value = self._get_new_filename()
        dlg = AcquisitionDialog(
            self, "Timelapse acquisition",
            "The same streams will be acquired multiple times, defined by the 'number of acquisitions'.\n"
            "The time separating each acquisition is defined by the 'period'.\n"
        )
        self._dlg = dlg
        dlg.addSettings(self, self.vaconf)
        ss = self._get_live_streams(tab.tab_data_model)
        for s in ss:
            if isinstance(
                    s,
                (ARStream, SpectrumStream, MonochromatorSettingsStream)):
                # TODO: instead of hard-coding the list, a way to detect the type
                # of live image?
                logging.info(
                    "Not showing stream %s, for which the live image is not spatial",
                    s)
                dlg.addStream(s, index=None)
            else:
                dlg.addStream(s)
        dlg.addButton("Cancel")
        dlg.addButton("Acquire", self.acquire, face_colour='blue')

        # Force to re-check the minimum period time
        self.period.value = self.period.value

        # Update acq time when streams are added/removed
        dlg.view.stream_tree.flat.subscribe(self._update_exp_dur, init=True)
        dlg.hidden_view.stream_tree.flat.subscribe(self._update_exp_dur,
                                                   init=True)
        # TODO: update the acquisition time whenever a setting changes

        # TODO: disable "acquire" button if no stream selected

        # TODO: also display the repetition and axis settings for the SPARC streams.

        ans = dlg.ShowModal()

        if ans == 0:
            logging.info("Acquisition cancelled")
        elif ans == 1:
            logging.info("Acquisition completed")
        else:
            logging.warning("Got unknown return code %s", ans)

        dlg.view.stream_tree.flat.unsubscribe(self._update_exp_dur)

        dlg.Destroy()
Example #29
0
    def start(self):
        # Fail if the live tab is not selected
        tab = self.main_app.main_data.tab.value
        if tab.name not in ("secom_live", "sparc_acqui"):
            box = wx.MessageDialog(self.main_app.main_frame,
                       "Timelapse acquisition must be done from the acquisition stream.",
                       "Timelapse acquisition not possible", wx.OK | wx.ICON_STOP)
            box.ShowModal()
            box.Destroy()
            return

        # On SPARC, fail if no ROI selected
        try:
            if tab.tab_data_model.semStream.roi.value == UNDEFINED_ROI:
                box = wx.MessageDialog(self.main_app.main_frame,
                           "You need to select a region of acquisition.",
                           "Timelapse acquisition not possible", wx.OK | wx.ICON_STOP)
                box.ShowModal()
                box.Destroy()
                return
        except AttributeError:
            pass # Not a SPARC

        # Stop the stream(s) playing to not interfere with the acquisition
        tab.streambar_controller.pauseStreams()

        self.filename.value = self._get_new_filename()
        dlg = AcquisitionDialog(self, "Timelapse acquisition",
                                "The same streams will be acquired multiple times, defined by the 'number of acquisitions'.\n"
                                "The time separating each acquisition is defined by the 'period'.\n")
        self._dlg = dlg
        dlg.addSettings(self, self.vaconf)
        ss = self._get_live_streams(tab.tab_data_model)
        for s in ss:
            if isinstance(s, (ARStream, SpectrumStream, MonochromatorSettingsStream)):
                # TODO: instead of hard-coding the list, a way to detect the type
                # of live image?
                logging.info("Not showing stream %s, for which the live image is not spatial", s)
                dlg.addStream(s, index=None)
            else:
                dlg.addStream(s)
        dlg.addButton("Cancel")
        dlg.addButton("Acquire", self.acquire, face_colour='blue')

        # Force to re-check the minimum period time
        self.period.value = self.period.value

        # Update acq time when streams are added/removed
        dlg.view.stream_tree.flat.subscribe(self._update_exp_dur, init=True)
        dlg.hidden_view.stream_tree.flat.subscribe(self._update_exp_dur, init=True)
        # TODO: update the acquisition time whenever a setting changes

        # TODO: disable "acquire" button if no stream selected

        # TODO: also display the repetition and axis settings for the SPARC streams.

        ans = dlg.ShowModal()

        if ans == 0:
            logging.info("Acquisition cancelled")
        elif ans == 1:
            logging.info("Acquisition completed")
        else:
            logging.warning("Got unknown return code %s", ans)

        dlg.Destroy()
Example #30
0
    def start(self):
        # Check the acquisition tab is open, and a CL-intensity stream is available
        ct = self.main_app.main_data.tab.value
        if ct.name == "sparc_acqui":
            cls = self._get_cl_intensity()
        else:
            cls = None
        if not cls:
            logging.info("Failed to start RGB CL intensity stream")
            dlg = wx.MessageDialog(self.main_app.main_frame,
                                   "No CL-intensity stream is currently open.\n"
                                   "You need to open a CL intensity stream "
                                   "and set the acquisition parameters.\n",
                                   caption="RGB CL intensity",
                                   style=wx.OK | wx.ICON_WARNING)
            dlg.ShowModal()
            dlg.Destroy()
            return

        # Normally, since Odemis v3.1, all CLSettingsStreams on systems with a cl-filter
        # have a "local axis" as a VA "axisFilter".
        assert any(hasattr(s, "axisFilter") for s in cls.streams)

        self._pause_streams()

        self._read_config()  # Restore filter values from the config file

        # immediately switch optical path, to save time
        self.main_app.main_data.opm.setPath(cls)  # non-blocking

        # Get survey stream too
        self._survey_s = self._get_sem_survey()
        self._cl_int_s = cls

        self._update_exp_dur()

        # Create a window
        dlg = AcquisitionDialog(self, "RGB CL intensity acquisition",
                                "Acquires a RGB CL-intensity image\n"
                                "Specify the relevant settings and start the acquisition\n"
                                )

        self.filename.value = self._get_new_filename()
        dlg.addSettings(self, conf=self.vaconf)
        dlg.addButton("Close")
        dlg.addButton("Acquire", self.acquire, face_colour='blue')

        # Show the window, and wait until the acquisition is over
        ans = dlg.ShowModal()

        # The window is closed
        if ans == 0:
            logging.debug("RGB CL intensity acquisition cancelled")
        elif ans == 1:
            logging.debug("RGB CL intensity acquisition completed")
        else:
            logging.warning("Unknown return code %d", ans)

        self._write_config()  # Store the filter values to restore them on next time

        # Make sure we don't hold reference to the streams forever
        self._survey_s = None
        self._cl_int_s = None

        dlg.Destroy()
Example #31
0
    def start(self, st):
        self._stream = st
        self.filename.value = self._get_new_filename()

        dlg = AcquisitionDialog(
            self, "Timelapse acquisition",
            "The same stream will be acquired multiple times, defined by the 'number of acquisitions'.\n"
            "The time separating each acquisition is defined by the 'period'.\n"
        )
        dlg.addSettings(self, self.vaconf)
        dlg.addStream(st)
        dlg.addButton("Cancel")
        dlg.addButton("Acquire", self.acquire, face_colour='blue')
        ans = dlg.ShowModal()

        if ans == 0:
            logging.info("Acquisition cancelled")
        elif ans == 1:
            logging.info("Acquisition completed")
        else:
            logging.warning("Got unknown return code %s", ans)