pykrait 0.2.1__tar.gz → 0.2.2__tar.gz

{pykrait-0.2.1 → pykrait-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pykrait
-Version: 0.2.1
+Version: 0.2.2
 Summary: Python Calcium Recording Analysis and Inference Toolbox
 Author-email: phaleanopsis <22663502+phaleanopsis@users.noreply.github.com>
 License: MIT
@@ -8,6 +8,7 @@ License-File: LICENSE
 Requires-Python: >=3.11
 Requires-Dist: aicspylibczi>=3.3.1
 Requires-Dist: bioio-czi>=2.4.0
+Requires-Dist: bioio-imageio
 Requires-Dist: bioio-ome-tiff>=1.1.0
 Requires-Dist: bioio-tifffile>=1.3.0
 Requires-Dist: bioio>=3.0.0
@@ -21,6 +22,7 @@ Requires-Dist: numcodecs<0.16
 Requires-Dist: numpy<2
 Requires-Dist: ome-types>=0.5.3
 Requires-Dist: ome-zarr>=0.10.2
+Requires-Dist: pandas>=2.3.1
 Requires-Dist: pip>=25.1.1
 Requires-Dist: pydantic<2
 Requires-Dist: pyyaml>=6.0.2

{pykrait-0.2.1 → pykrait-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pykrait"
-version = "0.2.1"
+version = "0.2.2"
 description = "Python Calcium Recording Analysis and Inference Toolbox"
 readme = { file = "README.md", content-type = "text/markdown" }
 license = { text = "MIT" }
@@ -14,6 +14,7 @@ dependencies = [
     "bioio-czi>=2.4.0",
     "bioio-ome-tiff>=1.1.0",
     "bioio-tifffile>=1.3.0",
+    "bioio-imageio",
     "cellpose>=4.0.5",
     "dask>=2025.5.1",
     "fsspec>=2022.8.0",
@@ -31,11 +32,12 @@ dependencies = [
     "scikit-image>=0.25.2",
     "scipy>=1.15.3",
     "xarray>2025",
+    "pandas>=2.3.1",
 ]
 
 [project.optional-dependencies]
 gui = [
-    "pyside6>=6.9.1"
+    "pyside6>=6.9.1",
 ]
 dev = [
     "build>=1.2.2.post1",
@@ -70,8 +72,11 @@ pythonpath = ["src"]
 testpaths = ["tests"]
 
 [tool.coverage.run]
-source = ["stavromueller_beta"]
+source = ["pykrait"]
 
 [tool.coverage.report]
 show_missing = true
 skip_covered = true
+
+[tool.setuptools.package-data]
+"pykrait.gui.resources" = ["logo.png"]

pykrait-0.2.2/src/pykrait/__main__.py

@@ -0,0 +1,9 @@
+"""
+Copyright © 2025 Pentabyteman
+"""
+# src/pykrait/__main__.py
+from pykrait.gui.app import AppController
+
+if __name__ == "__main__":
+    controller = AppController()
+    controller.run()

pykrait-0.2.2/src/pykrait/gui/app.py

@@ -0,0 +1,69 @@
+import sys
+import os
+from PySide6.QtCore import QSize
+from PySide6.QtGui import QIcon
+from PySide6.QtWidgets import QApplication
+from pykrait.gui.fileselection import FileSelectionWindow
+from pykrait.gui.mainwindow import MainWindow
+
+class AppController:
+    def __init__(self):
+        self.app = QApplication(sys.argv)
+
+        # Loading icon from resources
+        appIcon = QIcon()
+        try:
+            from importlib.resources import files
+            icon_path = files("pykrait.gui.resources").joinpath("logo.png")
+            os.path.exists(icon_path)
+        except Exception as e:
+            icon_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "pykrait/gui/resources", "logo.png"))
+            os.path.exists(icon_path)
+        if os.path.exists(icon_path):
+            appIcon.addFile(str(icon_path), QSize(16, 16))
+            appIcon.addFile(str(icon_path), QSize(24, 24))
+            appIcon.addFile(str(icon_path), QSize(32, 32))
+            appIcon.addFile(str(icon_path), QSize(48, 48))
+            appIcon.addFile(str(icon_path), QSize(64, 64))
+            appIcon.addFile(str(icon_path), QSize(256, 256))
+            self.app.setWindowIcon(appIcon)
+        else:
+            print(f"Warning: Icon file not found at {icon_path}")
+
+        # Set application name and version
+        self.app.setApplicationName("pyKrait")
+        self.app.setApplicationVersion("0.2.1")  
+        self.file_selection = FileSelectionWindow()
+        self.file_selection.analysis_complete.connect(self.on_analysis_complete)
+        self.file_selection.show()
+
+        # Keep references to windows
+        self.main_window = None
+
+    def on_analysis_complete(self, results):
+        # Called when analysis is done in FileSelectionWindow
+        # Hide file selection window
+        self.file_selection.close()
+        # Launch main window, keep reference
+        self.main_window = MainWindow(
+            frames=results["frames"],
+            mask=results["masks"],
+            rois=results["rois"],
+            mean_intensities=results["mean_intensities"],
+            analysis_output=results["analysis_output"],
+            analysis_params=results["analysis_parameters"],
+            app_controller=self
+        )
+        self.main_window.show()
+
+    def run(self):
+        sys.exit(self.app.exec())
+
+    def restart(self):
+        if self.main_window:
+            self.main_window.close()
+            self.main_window = None
+
+        self.file_selection = FileSelectionWindow()
+        self.file_selection.analysis_complete.connect(self.on_analysis_complete)
+        self.file_selection.show()

{pykrait-0.2.1 → pykrait-0.2.2}/src/pykrait/gui/async_workers.py

@@ -5,7 +5,9 @@ import os
 import traceback
 import numpy as np
 
-from pykrait.io.io import load_timelapse_lazy
+from skimage.measure import find_contours
+
+from pykrait.io.io import load_timelapse_lazy, read_label_image, get_pykrait_version, save_Txnrois
 from pykrait.preprocessing.segmentation import timelapse_projection, create_cellpose_segmentation
 from pykrait.preprocessing.timeseries_extraction import extract_mean_intensities
 from pykrait.trace_analysis.filtering import detrend_with_sinc_filter
@@ -13,6 +15,34 @@ from pykrait.trace_analysis.peak_analysis import find_peaks
 from pykrait.trace_analysis.oscillations import find_oscillating_rois
 from pykrait.pipeline.pipeline import AnalysisParameters, AnalysisOutput
 
+def get_pixel_contour_from_label_img(label_img:np.ndarray, orig_shape:tuple, target_shape:tuple) -> list:
+    """
+    Generates pixel contours from a labeled image, scaled to a target shape.
+
+    :param label_img: a label image where each pixel is labeled with an integer representing the ROI it belongs to
+    :type label_img: np.ndarray
+    :param orig_shape: original shape of the image (height, width)
+    :type orig_shape: tuple
+    :param target_shape: target shape to which the contours should be scaled (height, width)
+    :type target_shape: tuple
+    :return: returns a list of polygons representing the scaled contours of each ROI
+    :rtype: list
+    """ 
+    roi_polygons = []
+    orig_height, orig_width = orig_shape
+    target_height, target_width = target_shape
+    scale_y = target_height / orig_height
+    scale_x = target_width / orig_width
+    for index in range(1, label_img.max() + 1):  # skip background (0)
+        contours = find_contours(label_img == index, 0.5)
+        if contours:
+            contour = contours[0]
+            y, x = contour.T
+            y, x = y * scale_y, x * scale_x # rescales coordinates to target shape
+            polygon = list(zip(x, y))
+            roi_polygons.append(polygon)
+    return roi_polygons
+
 class ExtractIntensitiesWorker(QObject):
     progress_changed = Signal(int, str)    # progress percent, status message
     finished = Signal(dict)                # analysis results
@@ -30,6 +60,7 @@ class ExtractIntensitiesWorker(QObject):
             
             self.analysis_output.filename = self.analysis_output.filepath.split("/")[-1]
             print(f"Running analysis on {self.analysis_output.filename}")
+
             # Create analysis folder in the parent directory of the video file
             parent_dir = os.path.dirname(self.analysis_output.filepath)
             filename_wo_ext = os.path.splitext(self.analysis_output.filename)[0]
@@ -41,13 +72,21 @@ class ExtractIntensitiesWorker(QObject):
 
             timelapse_data, frame_interval, self.analysis_output.pixel_interval_y, self.analysis_output.pixel_interval_x = load_timelapse_lazy(file_path = self.analysis_output.filepath)
 
-            if frame_interval is None and self.analysis_parameters.frame_interval is None:
-                warnings.warn("No frame interval provided in the analysis parameters, and no frame interval could be inferred from the metadata. Defaulting to 1 second.")
-                self.analysis_output.frame_interval = 1  # Default to 1 second if not provided
-            elif self.analysis_parameters.frame_interval is None and frame_interval is not None:
+            if frame_interval is None and self.analysis_parameters.frame_interval is None: #nothing provided in metadata or parameters
+                warnings.warn("No frame interval found in metadata and no frame interval provided in parameters. Using default value of 1.0 seconds.", UserWarning)
+                self.analysis_output.frame_interval = 1.0
+            elif frame_interval is None and self.analysis_parameters.frame_interval is not None: # no metadata, but parameter provided
+                self.analysis_output.frame_interval = self.analysis_parameters.frame_interval
+            elif frame_interval is not None and self.analysis_parameters.frame_interval is None: # metadata provided, but no parameter
                 self.analysis_output.frame_interval = frame_interval
-            elif frame_interval is not None and self.analysis_parameters.frame_interval != frame_interval:
+            elif round(frame_interval, 2) == round(self.analysis_parameters.frame_interval, 2): # both provided and match
+                self.analysis_output.frame_interval = frame_interval
+            elif round(frame_interval, 2) != round(self.analysis_parameters.frame_interval, 2):
                 warnings.warn(f"Provided frame_interval ({self.analysis_parameters.frame_interval}) does not match inferred frame_interval ({frame_interval}) from metadata. Using provided value.")
+                self.analysis_output.frame_interval = self.analysis_parameters.frame_interval
+            else:
+                warnings.warn("Unexpected paramets in metadata frame interval {frame_interval} and provided frame interval {self.analyis_parameters.frame_interval}. Using default value of 1.0 seconds.", UserWarning)
+                self.analysis_output.frame_interval = 1.0
 
             if self.mode == "cellpose":
                 # perform the tproj
@@ -67,7 +106,7 @@ class ExtractIntensitiesWorker(QObject):
                 
             elif self.mode == "label_image":
                 self.progress_changed.emit(20, "Loading label image...")
-                masks = tifffile.imread(self.analysis_output.masks_path)
+                masks = read_label_image(self.analysis_output.masks_path)
                 tproj = None  # Not needed in this mode
 
             else:
@@ -79,6 +118,9 @@ class ExtractIntensitiesWorker(QObject):
             self.analysis_output.number_of_frames, self.analysis_output.number_of_cells = mean_intensities.shape
 
             # All done
+            self.progress_changed.emit(90, "Calculating ROI boundaries...")
+            rois = get_pixel_contour_from_label_img(masks, orig_shape=masks.shape, target_shape=(512, 512))
+
             self.progress_changed.emit(100, "Done.")
             
             results = {
@@ -86,6 +128,7 @@ class ExtractIntensitiesWorker(QObject):
                 'analysis_output': self.analysis_output,
                 'analysis_parameters': self.analysis_parameters,
                 'masks': masks,
+                'rois': rois,
                 'mean_intensities': mean_intensities
             }
             self.finished.emit(results)
@@ -165,3 +208,51 @@ class PeriodicCellWorker(QObject):
         except Exception as e:
             self.error.emit(e)
 
+class AnalysisSaveWorker(QObject):
+    finished = Signal(str)  # emit output file path or summary message
+    error = Signal(Exception)
+
+    def __init__(self, analysis_output, analysis_params, peaks: np.ndarray, detrended_intensities: np.ndarray, intensities: np.ndarray,
+        overwrite: bool,
+    ):
+        super().__init__()
+        self.analysis_output = analysis_output
+        self.analysis_params = analysis_params
+        self.peaks = peaks
+        self.detrended_intensities = detrended_intensities
+        self.intensities = intensities
+        self.overwrite = overwrite
+
+    def run(self):
+        try:
+            # Paths
+            filename = os.path.basename(self.analysis_output.filepath)
+            filename_wo_ext = os.path.splitext(filename)[0]
+            parent_dir = os.path.dirname(self.analysis_output.filepath)
+            analysis_folder = os.path.join(parent_dir, f"Analysis_{filename_wo_ext}")
+            os.makedirs(analysis_folder, exist_ok=True)
+
+            output_file = os.path.join(analysis_folder, f"{filename_wo_ext}_analysis_output.csv")
+            param_file = os.path.join(analysis_folder, f"{filename_wo_ext}_analysis_parameters.csv")
+
+            if not self.overwrite:
+                for f in [output_file, param_file]:
+                    if os.path.exists(f):
+                        raise FileExistsError(f"{f} already exists. Enable 'overwrite' to replace.")
+
+            # Save output
+            self.analysis_output.pykrait_version = get_pykrait_version()
+            self.analysis_output.timestamp = np.datetime64("now")
+
+            self.analysis_output.to_pandas().to_csv(output_file, index=False)
+            self.analysis_params.to_pandas().to_csv(param_file, index=False)
+
+            # Save arrays
+            save_Txnrois(self.peaks, self.analysis_output.frame_interval, os.path.join(analysis_folder, f"{filename_wo_ext}_peaks.csv"))
+            save_Txnrois(self.detrended_intensities, self.analysis_output.frame_interval, os.path.join(analysis_folder, f"{filename_wo_ext}_detrended_intensities.csv"))
+            save_Txnrois(self.intensities, self.analysis_output.frame_interval, os.path.join(analysis_folder, f"{filename_wo_ext}_raw_intensities.csv"))
+
+            self.finished.emit(f"Saved to {analysis_folder}")
+
+        except Exception as e:
+            self.error.emit(e)

{pykrait-0.2.1 → pykrait-0.2.2}/src/pykrait/gui/fileselection.py

@@ -206,7 +206,7 @@ class FileSelectionWindow(QWidget):
         last_dir = self.get_last_directory("last_model_dir")
         path, _ = QFileDialog.getOpenFileName(
             self, "Select Cellpose Model", last_dir,
-            filter="Model Files (*.npy *.pkl *.pt *.onnx);;All Files (*)"
+            filter="All Files (*)"
         )
         if path:
             self.model_path = path
@@ -219,7 +219,7 @@ class FileSelectionWindow(QWidget):
         last_dir = self.get_last_directory("last_image_dir")
         path, _ = QFileDialog.getOpenFileName(
             self, "Select Label Image", last_dir,
-            filter="Label Files (*.tif *.tiff *.npy);;All Files (*)"
+            filter="Label Files (*.tif *.tiff *.npy, *.png);;All Files (*)"
         )
         if path:
             self.label_image_path = path

{pykrait-0.2.1 → pykrait-0.2.2}/src/pykrait/gui/mainwindow.py

@@ -1,55 +1,25 @@
-import os
 import numpy as np
 import dask.array as da
 from matplotlib import cm
 
+
 from PySide6.QtWidgets import (
     QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, QMessageBox, QLabel,
     QFormLayout, QPushButton, QSplitter, QSlider, QDoubleSpinBox, QGroupBox,
     QCheckBox
 )
 from PySide6.QtCore import Qt, QPointF, Signal, QThread
-from PySide6.QtGui import QImage, QPixmap, QPen, QPolygonF
+from PySide6.QtGui import QImage, QPixmap, QPen, QPolygonF, QAction
 from PySide6.QtWidgets import QGraphicsView, QGraphicsScene, QGraphicsPixmapItem, QGraphicsPolygonItem
 
 from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg as FigureCanvas
 from matplotlib.figure import Figure
 
-from skimage.measure import find_contours
-
 from pykrait.io.io import get_pykrait_version
 from pykrait.pipeline.pipeline import AnalysisParameters, AnalysisOutput
-from pykrait.gui.async_workers import DetrendWorker, PeakDetectionWorker, PeriodicCellWorker
+from pykrait.gui.async_workers import DetrendWorker, PeakDetectionWorker, PeriodicCellWorker, AnalysisSaveWorker
 from pykrait.trace_analysis.peak_analysis import calculate_normalized_peaks
 
-def get_pixel_contour_from_label_img(label_img:np.ndarray, orig_shape:tuple, target_shape:tuple) -> list:
-    """
-    Generates pixel contours from a labeled image, scaled to a target shape.
-
-    :param label_img: a label image where each pixel is labeled with an integer representing the ROI it belongs to
-    :type label_img: np.ndarray
-    :param orig_shape: original shape of the image (height, width)
-    :type orig_shape: tuple
-    :param target_shape: target shape to which the contours should be scaled (height, width)
-    :type target_shape: tuple
-    :return: returns a list of polygons representing the scaled contours of each ROI
-    :rtype: list
-    """ 
-    roi_polygons = []
-    orig_height, orig_width = orig_shape
-    target_height, target_width = target_shape
-    scale_y = target_height / orig_height
-    scale_x = target_width / orig_width
-    for index in range(1, label_img.max() + 1):  # skip background (0)
-        contours = find_contours(label_img == index, 0.5)
-        if contours:
-            contour = contours[0]
-            y, x = contour.T
-            y, x = y * scale_y, x * scale_x # rescales coordinates to target shape
-            polygon = list(zip(x, y))
-            roi_polygons.append(polygon)
-    return roi_polygons
-
 class ImageDisplay(QGraphicsView):
     roiSelected = Signal(int)
 
@@ -165,15 +135,16 @@ class ImageDisplay(QGraphicsView):
 
 
 class MainWindow(QMainWindow):
-    def __init__(self, frames:da.Array, mask:np.ndarray, mean_intensities:np.ndarray, analysis_output:AnalysisOutput, analysis_params:AnalysisParameters):
+    def __init__(self, frames:da.Array, mask:np.ndarray, mean_intensities:np.ndarray, rois:list, analysis_output:AnalysisOutput, analysis_params:AnalysisParameters, app_controller=None):
         super().__init__()
+        self.app_controller = app_controller
         self.frames = frames
         self.mask = mask
-        self.rois = get_pixel_contour_from_label_img(label_img=self.mask, orig_shape=self.mask.shape, target_shape=(512, 512))
+        self.rois = rois
         self.intensities = mean_intensities
-        self.setWindowTitle("Calcium Imaging Analysis")
         self.analysis_output = analysis_output
         self.analysis_params = analysis_params
+        self.setWindowTitle(f"{self.analysis_output.filename}; pyKrait {get_pykrait_version()}")
 
         self.selected_roi = 0  # Default to first ROI
         self.current_frame = 0
@@ -181,6 +152,8 @@ class MainWindow(QMainWindow):
         self.detrended_intensities = None
         self.peaks = None
 
+        # menu bar
+        self._create_menu_bar()
         # Central widget and main layout
         central_widget = QWidget()
         main_layout = QHBoxLayout(central_widget)
@@ -346,6 +319,19 @@ class MainWindow(QMainWindow):
         self.find_peaks_btn.clicked.connect(self.find_peaks)
         self.periodicity_button.clicked.connect(self._start_periodicity_worker)
 
+    def _create_menu_bar(self):
+        self.menu_bar = self.menuBar()
+
+        file_menu = self.menu_bar.addMenu("File")
+
+        restart_action = QAction("New Analysis...", self)
+        restart_action.triggered.connect(self._on_new_analysis)
+        file_menu.addAction(restart_action)
+
+        exit_action = QAction("Exit", self)
+        exit_action.triggered.connect(self.close)
+        file_menu.addAction(exit_action)
+
     def on_slider_moved(self, idx):
         self.current_frame = idx
         self.image_display.display_dask_frame(self.frames[self.current_frame, 0, :, :])
@@ -442,8 +428,6 @@ class MainWindow(QMainWindow):
         self.peak_thread.finished.connect(self.peak_thread.deleteLater)
         self.peak_thread.start()
 
-
-
     def _start_detrend_worker(self, sinc_value):
         self.detrend_thread = QThread()
         self.detrend_worker = DetrendWorker(self.intensities, sinc_value, self.analysis_output.frame_interval)
@@ -473,7 +457,13 @@ class MainWindow(QMainWindow):
         self.find_peaks_btn.setEnabled(True)
         self.analysis_output.normalized_peaks = calculate_normalized_peaks(peaks, self.analysis_output.frame_interval)
         self.analysis_output.cells_four_peaks = np.sum(np.sum(self.peaks, axis=0) >= 4)
-        percentage_four_peaks = (self.analysis_output.cells_four_peaks / self.peaks.shape[0]) * 100
+        percentage_four_peaks = (self.analysis_output.cells_four_peaks / self.peaks.shape[1]) * 100
+
+        # update the analysis parameters
+        self.analysis_params.peak_min_width = self.peak_min_width_spin.value()
+        self.analysis_params.peak_max_width = self.peak_max_width_spin.value()
+        self.analysis_params.peak_prominence = self.peak_prominence_spin.value()
+        self.analysis_params.peak_min_height = self.peak_min_height_spin.value()
 
         # display the peak stats
         self.norm_peak_label.setText(f"{self.analysis_output.normalized_peaks:.2f}")
@@ -533,34 +523,33 @@ class MainWindow(QMainWindow):
         QMessageBox.critical(self, "Error", f"Periodic ROI analysis failed: {error}")
 
     def _save_analysis_results(self):
-        if self.analysis_output is None or self.analysis_params is None:
-            QMessageBox.warning(self, "Save Failed", "No analysis data to save.")
-            return
+        self.analysis_save_thread = QThread()
+        self.analysis_worker = AnalysisSaveWorker(
+            analysis_output=self.analysis_output,
+            analysis_params=self.analysis_params,
+            peaks=self.peaks,
+            detrended_intensities=self.detrended_intensities,
+            intensities=self.intensities,
+            overwrite=self.overwrite_checkbox.isChecked(),
+        )
+        self.analysis_worker.moveToThread(self.analysis_save_thread)
+
+        self.analysis_save_thread.started.connect(self.analysis_worker.run)
+        self.analysis_worker.finished.connect(self.on_save_finished)
+        self.analysis_worker.error.connect(self.on_save_error)
+        self.analysis_worker.finished.connect(self.analysis_save_thread.quit)
+        self.analysis_worker.finished.connect(self.analysis_worker.deleteLater)
+        self.analysis_save_thread.finished.connect(self.analysis_save_thread.deleteLater)
+
+        self.analysis_save_thread.start()
+
+
+    def on_save_finished(self, _: str):
+        QMessageBox.information(self, "Save Complete", "Analysis results saved successfully.")
 
-        try:
-            # Derive save paths
-            self.analysis_output.filename = os.path.basename(self.analysis_output.filepath)
-            filename_wo_ext = os.path.splitext(self.analysis_output.filename)[0]
-            parent_dir = os.path.dirname(self.analysis_output.filepath)
-            analysis_folder = os.path.join(parent_dir, f"Analysis_{filename_wo_ext}")
-
-            output_file = os.path.join(analysis_folder, f"{filename_wo_ext}_analysis_output.csv")
-            param_file = os.path.join(analysis_folder, f"{filename_wo_ext}_analysis_parameters.csv")
-
-            # Handle overwrite option
-            if not self.overwrite_checkbox.isChecked():
-                for f in [output_file, param_file]:
-                    if os.path.exists(f):
-                        QMessageBox.warning(self, "File Exists", "Analysis Output already exists. Uncheck 'Overwrite' to prevent overwrite.")
-                        return
-
-            # Save to CSV
-            self.analysis_output.pykrait_version = get_pykrait_version()
-            self.analysis_output.timestamp = np.datetime64('now')
-            self.analysis_output.to_pandas().to_csv(output_file, index=False)
-            self.analysis_params.to_pandas().to_csv(param_file, index=False)
-            print(f"Analysis results saved to {output_file} and {param_file}")
-
-        except Exception as e:
-            QMessageBox.critical(self, "Error", f"Failed to save: {str(e)}")
+    def on_save_error(self, e: Exception):
+        QMessageBox.critical(self, "Save Error", str(e))
 
+    def _on_new_analysis(self):
+        if self.app_controller:
+            self.app_controller.restart()

{pykrait-0.2.1 → pykrait-0.2.2}/src/pykrait/io/io.py

@@ -1,8 +1,10 @@
 import os
 import dask.array as da
+import numpy as np
+import pandas as pd
 import warnings
 import re
-from importlib.metadata import version, PackageNotFoundError
+from importlib.metadata import version
 
 from bioio import BioImage
 import bioio_tifffile
@@ -76,10 +78,15 @@ def load_timelapse_lazy(
 
     T, C, Z, Y, X = dask_img.shape
 
-    if Z == 1:
+    if T > 1 and Z == 1:
+        dask_img = dask_img[:, :, 0, :, :]  # shape: (T, C, Z, Y, X)
+    elif len([dim for dim in dask_img.shape if dim != 1]) == 3: #
+        print("Image has three non-singleton dimensions, presuming order is (T, Y, X).")
+        dask_img = _reorder_dask_array(dask_img)  # reorder to (T, C, Y, X)
         dask_img = dask_img[:, :, 0, :, :]  # shape: (T, C, Z, Y, X)
     else:
-        raise ValueError(f"Cannot drop Z dimension automatically: Z={Z}. Consider handling it explicitly.")
+        raise ValueError(f"Cannot drop Z dimension automatically: Z={Z}. Consider handling it explicitly. Image shape: {dask_img.shape}")
+
 
     print(f"Returning lazy array of shape {dask_img.shape} (T, C, Y, X)")
     return dask_img, frame_interval, y_um, x_um
@@ -110,4 +117,91 @@ def get_pykrait_version() -> str:
         return __version__
     except Exception as e:
         print(f"Could not retrieve pykrait version: {e}")
-        return None  # Default version if not found
+        return None  # Default version if not found
+
+def _reorder_dask_array(
+    dask_img: da.Array,
+) -> da.Array:
+    """Reorders a Dask array to the specified order.
+
+    :param dask_array: input Dask array
+    :type dask_array: da.Array
+    :return: reordered Dask array
+    :rtype: da.Array
+    """
+    shape = dask_img.shape
+    non_1_axes = [i for i, dim in enumerate(shape) if dim != 1]
+
+    if len(non_1_axes) < 3:
+        raise ValueError(f"Expected at least 3 non-1 dimensions in {shape}")
+
+    # Identify T, Y, X from non-1 dimensions
+    non1_indices = [i for i, d in enumerate(dask_img.shape) if d != 1]
+
+    T_axis = non1_indices[0]  # First non-singleton = T
+    Y_axis = non1_indices[-2] # Second last non-singleton = Y
+    X_axis = non1_indices[-1] # Last non-singleton = X
+
+    # Fill in dummy axes for C and Z
+    all_axes = list(range(5))
+    used_axes = {T_axis, Y_axis, X_axis}
+    unused_axes = [a for a in all_axes if a not in used_axes]
+
+    # Fix order to (T, C, Z, Y, X)
+    axis_map = {
+        'T': T_axis,
+        'C': unused_axes[0],
+        'Z': unused_axes[1],
+        'Y': Y_axis,
+        'X': X_axis
+    }
+
+    perm = [axis_map[k] for k in ['T', 'C', 'Z', 'Y', 'X']]
+
+    return dask_img.transpose(*perm)
+
+def read_label_image(
+    file_path: str,
+) -> np.ndarray:
+    """Reads a label image from a file and returns it as a Dask array.
+
+    :param file_path: path to the label image file
+    :type file_path: str
+    :return: Dask array of the label image
+    :rtype: da.Array
+    """
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"File not found: {file_path}")
+
+    try:
+        img = BioImage(file_path, reconstruct_mosaic=True).dask_data.compute()
+        return img[0,0,0,:,:]  # Assuming the label image is single-channel, return as (Y, X)
+    except Exception as e:
+        raise ValueError(f"Failed to read label image from {file_path}: {type(e).__name__}: {e}")
+        return None
+
+def save_Txnrois(array:np.ndarray, frame_interval: float, filepath:str) -> None:
+    """
+    Saves a T x n_roi array to a CSV file with a header to denote the ROIs and a time index
+
+    :param array: T x n_roi array to save
+    :type array: np.ndarray
+    :param filename: name of the output file
+    :type filename: str
+    :param frame_interval: frame interval in seconds
+    :type frame_interval: float
+    """
+    if not isinstance(array, np.ndarray):
+        raise TypeError("Input must be a numpy ndarray")
+    
+    if array.ndim != 2:
+        raise ValueError("Input array must be 2D (T x n_roi)")
+
+    n_frames, n_rois = array.shape
+    timepoints = np.round((np.arange(n_frames) * frame_interval), 2)
+    columns = [f"ROI_{i}" for i in range(n_rois)]
+
+    df = pd.DataFrame(np.round(array, 2), columns=columns, index=timepoints)
+    df.index.name = "Time (s)"
+    os.makedirs(os.path.dirname(filepath), exist_ok=True)
+    df.to_csv(filepath, index=True)

pykrait-0.2.1/src/pykrait/__main__.py

@@ -1,41 +0,0 @@
-"""
-Copyright © 2025 Pentabyteman
-"""
-# src/pykrait/__main__.py
-
-import sys
-from PySide6.QtWidgets import QApplication
-from pykrait.gui.fileselection import FileSelectionWindow
-from pykrait.gui.mainwindow import MainWindow
-
-class AppController:
-    def __init__(self):
-        self.app = QApplication(sys.argv)
-        self.file_selection = FileSelectionWindow()
-        self.file_selection.analysis_complete.connect(self.on_analysis_complete)
-        self.file_selection.show()
-
-        # Keep references to windows
-        self.main_window = None
-
-    def on_analysis_complete(self, results):
-        # Called when analysis is done in FileSelectionWindow
-        # Hide file selection window
-        self.file_selection.close()
-        # Launch main window, keep reference
-        self.main_window = MainWindow(
-            frames=results["frames"],
-            mask=results["masks"],
-            mean_intensities=results["mean_intensities"],
-            analysis_output=results["analysis_output"],
-            analysis_params=results["analysis_parameters"]
-        )
-        self.main_window.show()
-
-    def run(self):
-        sys.exit(self.app.exec())
-
-# In __main__.py
-if __name__ == "__main__":
-    controller = AppController()
-    controller.run()