waveorder 3.0.0a2__py3-none-any.whl → 3.0.0a3__py3-none-any.whl

waveorder/plugin/main_widget.py

@@ -35,13 +35,6 @@ try:
 except:
     pass
 
-try:
-    from waveorder.acq.acquisition_workers import (
-        BFAcquisitionWorker,
-        PolarizationAcquisitionWorker,
-    )
-except:
-    pass
 from waveorder.calib import Calibration
 from waveorder.calib.Calibration import LC_DEVICE_NAME, QLIPP_Calibration
 from waveorder.calib.calibration_workers import (
@@ -71,25 +64,6 @@ class MainWidget(QWidget):
 
     # Initialize class attributes
     disabled_button_style = "border: 1px solid rgb(65,72,81);"
-    bf_keywords = [
-        "bf",
-        "brightfield",
-        "bright",
-        "labelfree",
-        "label-free",
-        "lf",
-        "label",
-        "phase",
-        "ph",
-    ]
-    no_bf_msg = "\n".join(
-        textwrap.wrap(
-            f"No brightfield channel found. If you would like to acquire phase from brightfield,"
-            " please restart waveorder after adding a new channel to Micro-Manager with one of the"
-            " following case-insensitive keywords: " + ", ".join(bf_keywords),
-            width=70,
-        )
-    )
 
     def __init__(self, napari_viewer: Viewer):
         super().__init__()
@@ -103,9 +77,6 @@ class MainWidget(QWidget):
         # Override initial tab focus
         self.ui.tabWidget.setCurrentIndex(0)
 
-        # Set attributes need for enabling/disabling buttons
-        self.bf_channel_found = False
-
         # Disable buttons until connected to MM
         self._set_buttons_enabled(False)
 
@@ -158,88 +129,6 @@ class MainWidget(QWidget):
         )
         self.ui.qbutton_push_note.clicked[bool].connect(self.push_note)
 
-        # Acquisition tab
-        self.ui.qbutton_browse_save_dir.clicked[bool].connect(
-            self.browse_save_path
-        )
-        self.ui.le_save_dir.editingFinished.connect(self.enter_save_path)
-        self.ui.le_save_dir.setText(str(Path.cwd()))
-        self.ui.le_data_save_name.editingFinished.connect(self.enter_save_name)
-
-        self.ui.le_zstart.editingFinished.connect(self.enter_zstart)
-        self.ui.le_zstart.setText("-10")
-        self.enter_zstart()
-
-        self.ui.le_zend.editingFinished.connect(self.enter_zend)
-        self.ui.le_zend.setText("10")
-        self.enter_zend()
-
-        self.ui.le_zstep.editingFinished.connect(self.enter_zstep)
-        self.ui.le_zstep.setText("1")
-        self.enter_zstep()
-
-        self.ui.chb_use_gpu.stateChanged[int].connect(self.enter_use_gpu)
-        self.ui.le_gpu_id.editingFinished.connect(self.enter_gpu_id)
-
-        self.ui.cb_rotate_orientation.stateChanged[int].connect(
-            self.enter_rotate_orientation
-        )
-        self.ui.cb_flip_orientation.stateChanged[int].connect(
-            self.enter_flip_orientation
-        )
-        self.ui.cb_invert_phase_contrast.stateChanged[int].connect(
-            self.enter_invert_phase_contrast
-        )
-
-        # This parameter seems to be wired differently than others...investigate later
-        self.ui.le_recon_wavelength.editingFinished.connect(
-            self.enter_recon_wavelength
-        )
-        self.ui.le_recon_wavelength.setText("532")
-        self.enter_recon_wavelength()
-
-        self.ui.le_obj_na.editingFinished.connect(self.enter_obj_na)
-        self.ui.le_obj_na.setText("1.3")
-        self.enter_obj_na()
-
-        self.ui.le_cond_na.editingFinished.connect(self.enter_cond_na)
-        self.ui.le_cond_na.setText("0.5")
-        self.enter_cond_na()
-
-        self.ui.le_mag.editingFinished.connect(self.enter_mag)
-        self.ui.le_mag.setText("60")
-        self.enter_mag()
-
-        self.ui.le_ps.editingFinished.connect(self.enter_ps)
-        self.ui.le_ps.setText("6.9")
-        self.enter_ps()
-
-        self.ui.le_n_media.editingFinished.connect(self.enter_n_media)
-        self.ui.le_n_media.setText("1.3")
-        self.enter_n_media()
-
-        self.ui.le_pad_z.editingFinished.connect(self.enter_pad_z)
-        self.ui.cb_acq_mode.currentIndexChanged[int].connect(
-            self.enter_acq_mode
-        )
-
-        self.ui.cb_bg_method.currentIndexChanged[int].connect(
-            self.enter_bg_correction
-        )
-
-        self.ui.le_bg_path.editingFinished.connect(self.enter_acq_bg_path)
-        self.ui.qbutton_browse_bg_path.clicked[bool].connect(
-            self.browse_acq_bg_path
-        )
-        self.ui.qbutton_acq_ret_ori.clicked[bool].connect(self.acq_ret_ori)
-        self.ui.qbutton_acq_phase_from_bf.clicked[bool].connect(
-            self.acq_phase_from_bf
-        )
-
-        self.ui.qbutton_acq_ret_ori_phase.clicked[bool].connect(
-            self.acq_ret_ori_phase
-        )
-
         # hook to render overlay
         # acquistion updates existing layers and moves them to the top which triggers this event
         self.viewer.layers.events.moved.connect(self.handle_layers_updated)
@@ -250,12 +139,6 @@ class MainWidget(QWidget):
             self.handle_ret_max_slider_move
         )
 
-        # Reconstruction tab
-        self.ui.cb_phase_denoiser.currentIndexChanged[int].connect(
-            self.enter_phase_denoiser
-        )
-        self.enter_phase_denoiser()
-
         ## Initialize logging
         log_box = QtLogger(self.ui.te_log)
         log_box.setFormatter(logging.Formatter("%(levelname)s - %(message)s"))
@@ -269,8 +152,6 @@ class MainWidget(QWidget):
         self.mmc = None
         self.calib = None
         self.current_dir_path = str(Path.cwd())
-        self.current_save_path = str(Path.cwd())
-        self.current_bg_path = str(Path.cwd())
         self.directory = str(Path.cwd())
         self.calib_scheme = "4-State"
         self.calib_mode = "MM-Retardance"
@@ -288,18 +169,6 @@ class MainWidget(QWidget):
         self.bg_folder_name = "bg"
         self.n_avg = 5
         self.intensity_monitor = []
-        self.save_directory = str(Path.cwd())
-        self.save_name = None
-        self.bg_option = "None"
-        self.acq_mode = "2D"
-        self.gpu_id = 0
-        self.use_gpu = False
-        self.rotate_orientation = False
-        self.flip_orientation = False
-        self.invert_phase_contrast = False
-        self.pad_z = 0
-        self.phase_reconstructor = None
-        self.acq_bg_directory = ""
         self.auto_shutter = True
         self.lca_dac = None
         self.lcb_dac = None
@@ -348,17 +217,6 @@ class MainWidget(QWidget):
         self.ui.cb_lca.hide()
         self.ui.cb_lcb.hide()
 
-        # Background correction popups
-        self.ui.label_bg_path.setHidden(True)
-        self.ui.le_bg_path.setHidden(True)
-        self.ui.qbutton_browse_bg_path.setHidden(True)
-
-        # Reconstruction parameter popups
-        self.ui.le_rho.setHidden(True)
-        self.ui.label_phase_rho.setHidden(True)
-        self.ui.le_itr.setHidden(True)
-        self.ui.label_itr.setHidden(True)
-
         # Hide temporarily unsupported "Overlay" functions
         self.ui.tabWidget.setTabText(
             self.ui.tabWidget.indexOf(self.ui.Display), "Visualization"
@@ -379,23 +237,6 @@ class MainWidget(QWidget):
         self.setStyleSheet("QTabWidget::tab-bar {alignment: center;}")
         self.red_text = QColor(200, 0, 0, 255)
 
-        # Populate background correction GUI element
-        for i in range(3):
-            self.ui.cb_bg_method.removeItem(0)
-        bg_options = ["None", "Measured", "Estimated", "Measured + Estimated"]
-        tooltips = [
-            "No background correction.",
-            'Correct sample images with a background image acquired at an empty field of view, loaded from "Background Path".',
-            "Estimate sample background by fitting a 2D surface to the sample images. Works well when structures are spatially distributed across the field of view and a clear background is unavailable.",
-            'Apply "Measured" background correction and then "Estimated" background correction. Use to remove residual background after the sample retardance is corrected with measured background.',
-        ]
-        for i, bg_option in enumerate(bg_options):
-            wrapped_tooltip = "\n".join(textwrap.wrap(tooltips[i], width=70))
-            self.ui.cb_bg_method.addItem(bg_option)
-            self.ui.cb_bg_method.setItemData(
-                i, wrapped_tooltip, Qt.ToolTipRole
-            )
-
         # Populate calibration modes from docstring
         cal_docs = NumpyDocString(
             Calibration.QLIPP_Calibration.__init__.__doc__
@@ -409,15 +250,6 @@ class MainWidget(QWidget):
                 i, wrapped_tooltip, Qt.ToolTipRole
             )
 
-        # Populate acquisition mode tooltips
-        acq_tooltips = [
-            "Acquires data to estimate parameters in a 2D plane. For birefringence acquisitions, this mode will acquire 2D data. For phase acquisitions, this mode will acquire 3D data.",
-            "Acquires 3D data to estimate parameters in a 3D volume.",
-        ]
-        for i, tooltip in enumerate(acq_tooltips):
-            wrapped_tooltip = "\n".join(textwrap.wrap(tooltip, width=70))
-            self.ui.cb_acq_mode.setItemData(i, wrapped_tooltip, Qt.ToolTipRole)
-
         # make sure the top says waveorder and not 'Form'
         self.ui.tabWidget.parent().setObjectName("waveorder")
 
@@ -598,9 +430,6 @@ class MainWidget(QWidget):
             self.ui.qbutton_calibrate,
             self.ui.qbutton_capture_bg,
             self.ui.qbutton_calc_extinction,
-            self.ui.qbutton_acq_ret_ori,
-            self.ui.qbutton_acq_phase_from_bf,
-            self.ui.qbutton_acq_ret_ori_phase,
             self.ui.qbutton_load_calib,
             self.ui.qbutton_create_overlay,
         ]
@@ -616,13 +445,6 @@ class MainWidget(QWidget):
                 )
                 action_button.setStyleSheet(self.disabled_button_style)
 
-        if not self.bf_channel_found:
-            self.ui.qbutton_acq_phase_from_bf.setEnabled(False)
-            self.ui.qbutton_acq_phase_from_bf.setStyleSheet(
-                self.disabled_button_style
-            )
-            self.ui.qbutton_acq_phase_from_bf.setToolTip(self.no_bf_msg)
-
     def _enable_buttons(self):
         self._set_buttons_enabled(True)
 
@@ -708,75 +530,6 @@ class MainWidget(QWidget):
             le.setStyleSheet("")
             return True
 
-    def _check_requirements_for_acq(self, mode):
-        """
-        This function will loop through the parameters from a specific acquisition and make sure the user has
-        specified the necessary parameters.  If it finds an empty or missing parameters, it will set missing fields red
-        and stop the acquisition process.
-
-        Parameters
-        ----------
-        mode:           (str) 'birefringence' or 'phase' which denotes the type of acquisition
-
-        Returns
-        -------
-
-        """
-        # check if a QLIPP_Calibration object has been initialized
-        if mode != "phase" and not self.calib:
-            raise RuntimeError("Please run or load calibration first.")
-
-        # initialize the variable to keep track of the success of the requirement check
-        raise_error = False
-
-        # define the fields required for the specific acquisition modes.  Matches LineEdit object names
-        phase_required = {
-            "recon_wavelength",
-            "wavelength",
-            "mag",
-            "cond_na",
-            "obj_na",
-            "n_media",
-            "phase_strength",
-            "ps",
-            "zstep",
-        }
-
-        # Initalize all fields in their default style (not red).
-        for field in phase_required:
-            le = getattr(self.ui, f"le_{field}")
-            le.setStyleSheet("")
-
-        # Check generally required fields
-        if mode == "birefringence" or mode == "phase":
-            success = self._check_line_edit("save_dir")
-            if not success:
-                raise_error = True
-
-            # check background path if 'Measured' or 'Measured + Estimated' is selected
-            if (
-                self.bg_option == "Measured"
-                or self.bg_option == "Measured + Estimated"
-            ):
-                success = self._check_line_edit("bg_path")
-                if not success:
-                    raise_error = True
-
-        # Check phase specific fields
-        if mode == "phase":
-            for field in phase_required:
-                cont = self._check_line_edit(field)
-                if not cont:
-                    raise_error = True
-                else:
-                    continue
-
-        # Alert the user to check and enter in the missing parameters
-        if raise_error:
-            raise ValueError(
-                "Please enter in all of the parameters necessary for the acquisition"
-            )
-
     @Slot(bool)
     def toggle_mm_connection(self):
         """
@@ -900,17 +653,6 @@ class MainWidget(QWidget):
                     config_group_found = True
                 self.ui.cb_config_group.addItem(group)
 
-            # Populate the acquisition "BF channel" list with presets that contain any of these keywords
-            for ch in config_list:
-                if any(
-                    [
-                        keyword.lower() in ch.lower()
-                        for keyword in self.bf_keywords
-                    ]
-                ):
-                    self.ui.cb_acq_channel.addItem(ch)
-                    self.bf_channel_found = True
-
         logging.debug("Checked configs.")
         if not config_group_found:
             msg = (
@@ -922,18 +664,6 @@ class MainWidget(QWidget):
             )
             raise KeyError(msg)
 
-        if not self.bf_channel_found:
-            try:
-                self.ui.qbutton_acq_phase_from_bf.disconnect()
-            except Exception as exc:
-                print(exc.args)
-                logging.debug(exc.args)
-            self.ui.qbutton_acq_phase_from_bf.setStyleSheet(
-                self.disabled_button_style
-            )
-            self.ui.qbutton_acq_phase_from_bf.setToolTip(self.no_bf_msg)
-            self.ui.cb_acq_channel.setToolTip(self.no_bf_msg)
-
         # set startup LC control mode
         logging.debug("Setting startup LC control mode...")
         _devices = self.mmc.getLoadedDevices()
@@ -1229,7 +959,12 @@ class MainWidget(QWidget):
     @Slot(tuple)
     def handle_phase_image_update(self, value):
         phase, scale = value
-        name = "Phase2D" if self.acq_mode == "2D" else "Phase3D"
+        # Determine name based on data dimensionality
+        name = (
+            "Phase2D"
+            if phase.ndim == 2 or (phase.ndim > 2 and phase.shape[0] == 1)
+            else "Phase3D"
+        )
 
         # Add new layer if none exists, otherwise update layer data
         self._add_or_update_image_layer(phase, name, scale=scale)
@@ -1273,57 +1008,12 @@ class MainWidget(QWidget):
     def handle_reconstruction_store_update(self, value):
         self.reconstruction_data_path = value
 
-    # This seems to be unused
-    # @Slot(tuple)
-    # def handle_reconstruction_dim_update(self, value):
-    #     p, t, c = value
-    #     layer_name = self.worker.manager.config.data_save_name
-
-    #     if p == 0 and t == 0 and c == 0:
-    #         self.reconstruction_data = WaveorderReader(
-    #             self.reconstruction_data_path, "zarr"
-    #         )
-    #         self.viewer.add_image(
-    #             self.reconstruction_data.get_zarr(p),
-    #             name=layer_name + f"_Pos_{p:03d}",
-    #         )
-
-    #         self.viewer.dims.set_axis_label(0, "T")
-    #         self.viewer.dims.set_axis_label(1, "C")
-    #         self.viewer.dims.set_axis_label(2, "Z")
-
-    #     # Add each new position as a new layer in napari
-    #     name = layer_name + f"_Pos_{p:03d}"
-    #     if name not in self.viewer.layers:
-    #         self.reconstruction_data = WaveorderReader(
-    #             self.reconstruction_data_path, "zarr"
-    #         )
-    #         self.viewer.add_image(
-    #             self.reconstruction_data.get_zarr(p), name=name
-    #         )
-
-    #     # update the napari dimension slider position if the user hasn't specified to pause updates
-    #     if not self.pause_updates:
-    #         self.viewer.dims.set_current_step(0, t)
-    #         self.viewer.dims.set_current_step(1, c)
-
-    #     self.last_p = p
-
     @Slot(bool)
     def browse_dir_path(self):
         result = self._open_file_dialog(self.current_dir_path, "dir")
         self.directory = result
         self.current_dir_path = result
         self.ui.le_directory.setText(result)
-        self.ui.le_save_dir.setText(result)
-        self.save_directory = result
-
-    @Slot(bool)
-    def browse_save_path(self):
-        result = self._open_file_dialog(self.current_save_path, "dir")
-        self.save_directory = result
-        self.current_save_path = result
-        self.ui.le_save_dir.setText(result)
 
     @Slot(bool)
     def browse_data_dir(self):
@@ -1342,8 +1032,6 @@ class MainWidget(QWidget):
         path = self.ui.le_directory.text()
         if os.path.exists(path):
             self.directory = path
-            self.save_directory = path
-            self.ui.le_save_dir.setText(path)
         else:
             self.ui.le_directory.setText("Path Does Not Exist")
 
@@ -1476,184 +1164,6 @@ class MainWidget(QWidget):
         else:
             logging.getLogger().setLevel(logging.DEBUG)
 
-    @Slot()
-    def enter_save_path(self):
-        path = self.ui.le_save_dir.text()
-        if os.path.exists(path):
-            self.save_directory = path
-            self.current_save_path = path
-        else:
-            self.ui.le_save_dir.setText("Path Does Not Exist")
-
-    @Slot()
-    def enter_save_name(self):
-        name = self.ui.le_data_save_name.text()
-        self.save_name = name
-
-    @Slot()
-    def enter_zstart(self):
-        self.z_start = float(self.ui.le_zstart.text())
-
-    @Slot()
-    def enter_zend(self):
-        self.z_end = float(self.ui.le_zend.text())
-
-    @Slot()
-    def enter_zstep(self):
-        self.z_step = float(self.ui.le_zstep.text())
-
-    @Slot()
-    def enter_acq_mode(self):
-        state = self.ui.cb_acq_mode.currentIndex()
-        if state == 0:
-            self.acq_mode = "2D"
-        elif state == 1:
-            self.acq_mode = "3D"
-
-    @Slot()
-    def enter_phase_denoiser(self):
-        state = self.ui.cb_phase_denoiser.currentIndex()
-        if state == 0:
-            self.phase_regularizer = "Tikhonov"
-            self.ui.label_itr.setHidden(True)
-            self.ui.label_phase_rho.setHidden(True)
-            self.ui.le_rho.setHidden(True)
-            self.ui.le_itr.setHidden(True)
-
-        elif state == 1:
-            self.phase_regularizer = "TV"
-            self.ui.label_itr.setHidden(False)
-            self.ui.label_phase_rho.setHidden(False)
-            self.ui.le_rho.setHidden(False)
-            self.ui.le_itr.setHidden(False)
-
-    @Slot()
-    def enter_acq_bg_path(self):
-        path = self.ui.le_bg_path.text()
-        if os.path.exists(path):
-            self.acq_bg_directory = path
-            self.current_bg_path = path
-        else:
-            self.ui.le_bg_path.setText("Path Does Not Exist")
-
-    @Slot(Path)
-    def handle_bg_path_update(self, value: Path):
-        """
-        Handles the update of the most recent background folderpath from
-        BackgroundWorker to display in the reconstruction texbox.
-
-        Parameters
-        ----------
-        value : str
-            most recent captured background folderpath
-        """
-        path = value
-        if path.exists():
-            self.acq_bg_directory = path
-            self.current_bg_path = path
-            self.ui.le_bg_path.setText(str(path))
-        else:
-            msg = """
-                Background acquisition was not successful.
-                Check latest background capture saving directory!
-                """
-            raise RuntimeError(msg)
-
-    @Slot(bool)
-    def browse_acq_bg_path(self):
-        result = self._open_file_dialog(self.current_bg_path, "dir")
-        self.acq_bg_directory = result
-        self.current_bg_path = result
-        self.ui.le_bg_path.setText(result)
-
-    @Slot()
-    def enter_bg_correction(self):
-        state = self.ui.cb_bg_method.currentIndex()
-        if state == 0:
-            self.ui.label_bg_path.setHidden(True)
-            self.ui.le_bg_path.setHidden(True)
-            self.ui.qbutton_browse_bg_path.setHidden(True)
-            self.bg_option = "None"
-        elif state == 1:
-            self.ui.label_bg_path.setHidden(False)
-            self.ui.le_bg_path.setHidden(False)
-            self.ui.qbutton_browse_bg_path.setHidden(False)
-            self.bg_option = "Measured"
-        elif state == 2:
-            self.ui.label_bg_path.setHidden(True)
-            self.ui.le_bg_path.setHidden(True)
-            self.ui.qbutton_browse_bg_path.setHidden(True)
-            self.bg_option = "Estimated"
-        elif state == 3:
-            self.ui.label_bg_path.setHidden(False)
-            self.ui.le_bg_path.setHidden(False)
-            self.ui.qbutton_browse_bg_path.setHidden(False)
-            self.bg_option = "Measured + Estimated"
-
-    @Slot()
-    def enter_gpu_id(self):
-        self.gpu_id = int(self.ui.le_gpu_id.text())
-
-    @Slot()
-    def enter_use_gpu(self):
-        state = self.ui.chb_use_gpu.checkState().value
-        if state == 2:
-            self.use_gpu = True
-        elif state == 0:
-            self.use_gpu = False
-
-    @Slot()
-    def enter_rotate_orientation(self):
-        state = self.ui.cb_rotate_orientation.checkState().value
-        if state == 2:
-            self.rotate_orientation = True
-        elif state == 0:
-            self.rotate_orientation = False
-
-    @Slot()
-    def enter_flip_orientation(self):
-        state = self.ui.cb_flip_orientation.checkState().value
-        if state == 2:
-            self.flip_orientation = True
-        elif state == 0:
-            self.flip_orientation = False
-
-    @Slot()
-    def enter_invert_phase_contrast(self):
-        state = self.ui.cb_invert_phase_contrast.checkState().value
-        if state == 2:
-            self.invert_phase_contrast = True
-        elif state == 0:
-            self.invert_phase_contrast = False
-
-    @Slot()
-    def enter_recon_wavelength(self):
-        self.recon_wavelength = int(self.ui.le_recon_wavelength.text())
-
-    @Slot()
-    def enter_obj_na(self):
-        self.obj_na = float(self.ui.le_obj_na.text())
-
-    @Slot()
-    def enter_cond_na(self):
-        self.cond_na = float(self.ui.le_cond_na.text())
-
-    @Slot()
-    def enter_mag(self):
-        self.mag = float(self.ui.le_mag.text())
-
-    @Slot()
-    def enter_ps(self):
-        self.ps = float(self.ui.le_ps.text())
-
-    @Slot()
-    def enter_n_media(self):
-        self.n_media = float(self.ui.le_n_media.text())
-
-    @Slot()
-    def enter_pad_z(self):
-        self.pad_z = int(self.ui.le_pad_z.text())
-
     @Slot()
     def enter_pause_updates(self):
         """
@@ -2007,85 +1517,9 @@ class MainWidget(QWidget):
         self.ui.qbutton_stop_calib.clicked.connect(self.worker.quit)
         self.worker.aborted.connect(self._handle_calib_abort)
 
-        # Connect to BG Correction Path
-        self.worker.bg_path_update_emitter.connect(self.handle_bg_path_update)
-
         # Start Capture Background Thread
         self.worker.start()
 
-    @Slot(bool)
-    def acq_ret_ori(self):
-        """
-        Wrapper function to acquire birefringence stack/image and plot in napari
-        Returns
-        -------
-
-        """
-
-        self._check_requirements_for_acq("birefringence")
-
-        # Init Worker and thread
-        self.worker = PolarizationAcquisitionWorker(
-            self, self.calib, "birefringence"
-        )
-
-        # Connect Handlers
-        self.worker.bire_image_emitter.connect(self.handle_bire_image_update)
-        self.worker.started.connect(self._disable_buttons)
-        self.worker.finished.connect(self._enable_buttons)
-        self.worker.errored.connect(self._handle_acq_error)
-
-        # Start Thread
-        self.worker.start()
-
-    @Slot(bool)
-    def acq_phase_from_bf(self):
-        """
-        Wrapper function to acquire phase stack and plot in napari
-        """
-
-        self._check_requirements_for_acq("phase")
-
-        # Init worker and thread
-        self.worker = BFAcquisitionWorker(self)
-
-        # Connect Handlers
-        self.worker.phase_image_emitter.connect(self.handle_phase_image_update)
-        self.worker.phase_reconstructor_emitter.connect(
-            self.handle_qlipp_reconstructor_update
-        )
-        self.worker.started.connect(self._disable_buttons)
-        self.worker.finished.connect(self._enable_buttons)
-        self.worker.errored.connect(self._handle_acq_error)
-
-        # Start thread
-        self.worker.start()
-
-    @Slot(bool)
-    def acq_ret_ori_phase(self):
-        """
-        Wrapper function to acquire both birefringence and phase stack and plot in napari
-        """
-
-        self._check_requirements_for_acq("phase")
-
-        # Init worker and thread
-        self.worker = PolarizationAcquisitionWorker(self, self.calib, "all")
-
-        # connect handlers
-        self.worker.phase_image_emitter.connect(self.handle_phase_image_update)
-        self.worker.phase_reconstructor_emitter.connect(
-            self.handle_qlipp_reconstructor_update
-        )
-        self.worker.bire_image_emitter.connect(self.handle_bire_image_update)
-        self.worker.started.connect(self._disable_buttons)
-        self.worker.finished.connect(self._enable_buttons)
-        self.worker.errored.connect(self._handle_acq_error)
-        self.ui.qbutton_stop_acq.clicked.connect(self.worker.quit)
-
-        # Start Thread
-        self.worker.start()
-
     @Slot(bool)
     def save_config(self):
         path = self._open_file_dialog(self.save_config_path, "save")