microEye v2.3.9

Enhancements:

- TIFF Viewer:
    - File System: Added context menu with "Reveal in Folder", "Create
      New Folder", and base path shortcuts.
    - [BUG] Localization View: Fixed issue where exporting
      super-resolution images would fail.

- Pycro-Manager:
    - [BUG] GUI freeze caused by focus stabilization on
      `PycroStage` with Java backend (tested with FOC100).
    - Introduced background daemon to handle `Core` calls on a separate
      thread, an attempt to resolve GUI responsiveness issues.

Future Updates:
	- Finalized Pycro-Manager Integration with XY-Stage and Focus
      Stabilization.
	- MacOS compatibility testing
	- Acquisition Experiments Designer tools (continued development)
	- 3D Localization fitting from Experimental PSF
	- Introduction of 2D/3D Single-Particle Tracking

Author: samhitech

README.md

@@ -7,11 +7,11 @@ The **`microEye`** is a Python toolkit for fluorescence microscopy that supports
 This toolkit is compatible with the [hardware](#hardware) used in our microscope. For further details, refer to the [miEye microscope paper](https://doi.org/10.1016/j.ohx.2022.e00368) and [OSF project](http://doi.org/10.17605/osf.io/j2fqy).
 
 ```bash
-   __  ____              ____                ___    ____  ___ 
-  /  |/  (_)__________  / __/_ _____   _  __|_  |  |_  / ( _ )
- / /|_/ / / __/ __/ _ \/ _// // / -_) | |/ / __/_ _/_ <_/ _  |
-/_/  /_/_/\__/_/  \___/___/\_, /\__/  |___/____(_)____(_)___/ 
-                          /___/
+ __  __ _            ___               ___   ____ ___ 
+|  \/  (_)__ _ _ ___| __|  _ ___  __ _|_  ) |__ // _ \
+| |\/| | / _| '_/ _ \ _| || / -_) \ V // / _ |_ \\_, /
+|_|  |_|_\__|_| \___/___\_, \___|  \_//___(_)___(_)_/ 
+                        |__/
 ```
 
 ![Package Health](https://snyk.io/advisor/python/microEye/badge.svg)

src/microEye/_version.py

@@ -1,2 +1,2 @@
-version_info = (2, 3, 8)
+version_info = (2, 3, 9)
 __version__ = '.'.join(map(str, version_info))

src/microEye/analysis/multi_viewer.py

@@ -203,13 +203,77 @@ def setupFileSystemTab(self, path):
         # Connect double-click signal to a method that uses QTimer
         self.tree.doubleClicked.connect(self._open_file)
 
+        # Create Tree view context menu
+        self.tree.setContextMenuPolicy(Qt.CustomContextMenu)
+        self.tree.customContextMenuRequested.connect(self._show_tree_context_menu)
+
         # Add the File system tab contents
         self.imsq_pattern = QtWidgets.QLineEdit('/image_0*.ome.tif')
 
         self.file_tree_layout.addWidget(QtWidgets.QLabel('Image Sequence pattern:'))
         self.file_tree_layout.addWidget(self.imsq_pattern)
         self.file_tree_layout.addWidget(self.tree)
 
+    def _show_tree_context_menu(self, position):
+        index = self.tree.indexAt(position)
+        if not index.isValid():
+            return
+
+        menu = QtWidgets.QMenu()
+        reveal_action = menu.addAction('Reveal in Explorer')
+        new_folder_action = menu.addAction('New Folder')
+        menu.addSeparator()
+
+        # Root path shortcuts
+        root_action = menu.addAction('This PC (Root Path)')
+        home_action = menu.addAction('Home (User Directory)')
+        desktop_action = menu.addAction('Desktop')
+        initial_action = menu.addAction('Initial Path')
+        working_dir_action = menu.addAction('Working Directory')
+
+        action = menu.exec(self.tree.viewport().mapToGlobal(position))
+        if action == reveal_action:
+            path = self.model.filePath(index)
+            folder = path if os.path.isdir(path) else os.path.dirname(path)
+            os.startfile(folder)
+        elif action == new_folder_action:
+            self._create_new_folder()
+        elif action == home_action:
+            home = os.path.expanduser('~')
+            self.tree.setRootIndex(self.model.index(home))
+        elif action == desktop_action:
+            desktop = os.path.join(os.path.expanduser('~'), 'Desktop')
+            self.tree.setRootIndex(self.model.index(desktop))
+        elif action == root_action:
+            self.tree.setRootIndex(self.model.index(''))
+        elif action == initial_action:
+            self.tree.setRootIndex(self.model.index(self.path))
+        elif action == working_dir_action:
+            self.tree.setRootIndex(
+                self.model.index(os.path.dirname(os.path.abspath(__package__)))
+            )
+
+    def _create_new_folder(self):
+        index = self.tree.currentIndex()
+        if not index.isValid():
+            return
+
+        path = self.model.filePath(index)
+        if not os.path.isdir(path):
+            path = os.path.dirname(path)
+
+        new_folder_name, ok = QtWidgets.QInputDialog.getText(
+            self, 'New Folder', 'Enter folder name:'
+        )
+        if ok and new_folder_name:
+            new_folder_path = os.path.join(path, new_folder_name)
+            try:
+                os.makedirs(new_folder_path)
+            except OSError as e:
+                QtWidgets.QMessageBox.critical(
+                    self, 'Error', f'Could not create folder: {e}'
+                )
+
     def tabifyDocks(self):
         # Tabify docks
         pass

src/microEye/analysis/viewer/localizations.py

@@ -285,53 +285,41 @@ def render_loc(self):
         ndarray or None
             Rendered super-res image or None.
         '''
-        for idx, localizations in enumerate(self.fittingResults):
-            if localizations is None:
-                continue
+        if not self.fittingResults:
+            return
 
-            if len(localizations) <= 0:
-                continue
+        images = [None] * len(self.fittingResults)
 
-            render_idx = self.render_cbox.currentData()
-            projection = self.projection_cbox.currentData()
+        render_idx = self.render_cbox.currentData()
+        projection = self.projection_cbox.currentData()
+        xy_bin = self.xy_binsize.value()
+        z_bin = self.z_binsize.value()
+        auto_levels = self.auto_level.isChecked()
+
+        renderer = BaseRenderer(xy_bin, z_bin, RenderModes(render_idx))
+
+        for idx, localizations in enumerate(self.fittingResults):
+            if not localizations or len(localizations) <= 0:
+                continue
 
-            renderClass = BaseRenderer(
-                self.xy_binsize.value(),
-                self.z_binsize.value(),
-                RenderModes(render_idx),
-            )
             if 0 <= projection < 3:
-                img = renderClass.render(
+                rendered_img = renderer.render(
                     Projection(projection),
                     localizations.data[DataColumns.X],
                     localizations.data[DataColumns.Y],
                     localizations.data[DataColumns.Z],
                     localizations.data[DataColumns.INTENSITY],
                 )
 
-                self.setImage(
-                    img, index=idx, autoLevels=self.auto_level.isChecked()
-                )
-
-                if projection == 0:
-                    self.view_box.setAspectLocked(True, 1)
-                else:
-                    self.view_box.setAspectLocked(
-                        True, self.xy_binsize.value() / self.z_binsize.value()
-                    )
+                aspect = 1 if projection == 0 else xy_bin / z_bin
+                self.view_box.setAspectLocked(True, aspect)
             elif 3 <= projection < 6:
-                projection -= 3
-
-                if projection == 0:
-                    self.view_box.setAspectLocked(True, 1)
-                    width = self.z_binsize.value()
-                else:
-                    self.view_box.setAspectLocked(
-                        True, self.xy_binsize.value() / self.z_binsize.value()
-                    )
-                    width = self.xy_binsize.value()
+                slice_proj = projection - 3
+                aspect = 1 if slice_proj == 0 else xy_bin / z_bin
+                self.view_box.setAspectLocked(True, aspect)
+                width = z_bin if slice_proj == 0 else xy_bin
 
-                img = renderClass.render_slice(
+                rendered_img = renderer.render_slice(
                     Projection(projection),
                     localizations.data[DataColumns.X],
                     localizations.data[DataColumns.Y],
@@ -340,10 +328,13 @@ def render_loc(self):
                     self.position.value(),
                     width,
                 )
+            else:
+                continue
 
-                self.setImage(
-                    img, index=idx, autoLevels=self.auto_level.isChecked()
-                )
+            self.setImage(rendered_img, index=idx, autoLevels=auto_levels)
+            images[idx] = rendered_img
+
+        return images
 
     def extract_z(self):
         '''Extract Z values from the fitting results.'''
@@ -1276,7 +1267,7 @@ def export_loc(self, filename=None):
                     )
 
             if 'Super-res image' in options:
-                sres_img = self.render_loc()
+                sres_img = self.render_loc()[self.image_layers.currentIndex]
                 tf.imwrite(
                     re.sub(r'(\.h5|\.tsv)$', '_super_res.tif', filename),
                     sres_img,