pykrait 0.3.0__tar.gz → 0.3.1__tar.gz

{pykrait-0.3.0 → pykrait-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pykrait
-Version: 0.3.0
+Version: 0.3.1
 Summary: Python Calcium Recording Analysis and Inference Toolbox
 Author-email: phaleanopsis <22663502+phaleanopsis@users.noreply.github.com>
 License: MIT

{pykrait-0.3.0 → pykrait-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pykrait"
-version = "0.3.0"
+version = "0.3.1"
 description = "Python Calcium Recording Analysis and Inference Toolbox"
 readme = { file = "README.md", content-type = "text/markdown" }
 license = { text = "MIT" }

{pykrait-0.3.0 → pykrait-0.3.1}/src/pykrait/gui/app.py

@@ -1,5 +1,6 @@
 import sys
 import os
+import warnings
 from PySide6.QtCore import QSize
 from PySide6.QtGui import QIcon
 from PySide6.QtWidgets import QApplication
@@ -7,8 +8,15 @@ from pykrait.gui.fileselection import FileSelectionWindow
 from pykrait.gui.mainwindow import MainWindow
 from pykrait.io.files import get_pykrait_version
 
+def warning_no_source_line(message, category, filename, lineno, file=None, line=None):
+    return f"{filename}:{lineno}: {category.__name__}: {message}\n"
+
 class AppController:
     def __init__(self):
+
+        # format warnings to not print the source line every time
+        warnings.formatwarning = warning_no_source_line
+        
         self.app = QApplication(sys.argv)
 
         # Loading icon from resources

{pykrait-0.3.0 → pykrait-0.3.1}/src/pykrait/gui/mainwindow.py

@@ -1,4 +1,5 @@
 import numpy as np
+import traceback
 import dask.array as da
 from matplotlib import cm
 from pathlib import Path
@@ -44,8 +45,8 @@ from PySide6.QtWidgets import (
 from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg as FigureCanvas
 from matplotlib.figure import Figure
 
-from pykrait.io.files import get_pykrait_version, concat_analysis_outputs
-from pykrait.io.images import read_label_image
+from pykrait.io.files import get_pykrait_version, concat_analysis_files
+from pykrait.io.images import read_image
 from pykrait.pipeline.pipeline import AnalysisParameters, AnalysisOutput
 from pykrait.gui.async_workers import (
     DetrendWorker,
@@ -56,7 +57,6 @@ from pykrait.gui.async_workers import (
     AdjacencyMatrixWorker
 )
 from pykrait.gui.custom_widgets import ToggleSwitch, CollapsibleBox
-from pykrait.trace_analysis.peak_analysis import calculate_normalized_peaks
 
 
 class ImageDisplay(QGraphicsView):
@@ -292,7 +292,7 @@ class MainWindow(QMainWindow):
         self.show_detrended: bool = False
         self.detrended_intensities = None
         self.peaks = None
-        self.tproj = read_label_image(self.analysis_output.tproj_path)
+        self.tproj = read_image(self.analysis_output.tproj_path)
         # menu bar
         self._create_menu_bar()
         # Central widget and main layout
@@ -560,7 +560,7 @@ class MainWindow(QMainWindow):
         self.time_window_spin.setDecimals(2)
         self.time_window_spin.setMinimum(0)
         self.time_window_spin.setMaximum(100)
-        self.time_window_spin.setValue(5.0)  # default value
+        self.time_window_spin.setValue(10.0)  # default value
         synch_layout.addRow("Time Window [s]:", self.time_window_spin)
 
         # Action buttons
@@ -1043,7 +1043,8 @@ class MainWindow(QMainWindow):
         self.calculate_synchronous_btn.setEnabled(True)
 
     def _synchronicity_error(self, error):
-        QMessageBox.critical(self, "Error", f"Synchronicity analysis failed: {error}")
+        tb_str = "".join(traceback.format_exception(type(error), error, error.__traceback__))
+        QMessageBox.critical(self, "Error", f"Synchronicity analysis failed: {tb_str}")
         self.calculate_synchronous_btn.setEnabled(True)
 
     def _save_analysis_results(self):
@@ -1100,7 +1101,7 @@ class MainWindow(QMainWindow):
             root_folder = image_path.parent
 
             # Call your concatenation function
-            concat_analysis_outputs(str(root_folder))
+            concat_analysis_files(str(root_folder))
 
             QMessageBox.information(
                 self,

{pykrait-0.3.0 → pykrait-0.3.1}/src/pykrait/io/files.py

@@ -114,7 +114,7 @@ def save_NroisxF(
     df.to_csv(filepath, index=True, compression="zstd")
 
 
-def concat_analysis_outputs(root_folder: str) -> None:
+def concat_analysis_files(root_folder: str, filetype:str="output") -> None:
     """
     Concatenates all *_analysis_output.csv files in the given root folder and its subdirectories into a single CSV file named experiment_overview.csv.
 
@@ -124,17 +124,30 @@ def concat_analysis_outputs(root_folder: str) -> None:
     """
     root = Path(root_folder)
     # Search recursively for *_analysis_output.csv
-    csv_files = [
-        f
-        for f in root.rglob("*_analysis_output.csv")
-        if not f.name.startswith(".")  # skip hidden files
-    ]
-
-    if not csv_files:
-        raise FileNotFoundError(
-            "No *_analysis_output.csv files found in the directory or subdirectories."
-        )
-
+    if filetype == "output":
+        csv_files = [
+            f
+            for f in root.rglob("*_analysis_output.csv")
+            if not f.name.startswith(".")  # skip hidden files
+        ]
+        if not csv_files:
+            raise FileNotFoundError(
+                "No *_analysis_output.csv files found in the directory or subdirectories."
+            )
+        output_path = root / "analysis_output_overview.csv"
+    elif filetype == "parameters":
+        csv_files = [
+            f
+            for f in root.rglob("*_analysis_parameters.csv")
+            if not f.name.startswith(".")  # skip hidden files
+        ]
+        if not csv_files:
+            raise FileNotFoundError(
+                "No *_analysis_parameters.csv files found in the directory or subdirectories."
+            )
+        output_path = root / "analysis_params_overview.csv"
+    else:
+        raise ValueError(f"Unexpected filetype: {filetype}, use 'parameters' or 'output'")
     dfs = []
     for f in csv_files:
         df = pd.read_csv(f)
@@ -143,7 +156,7 @@ def concat_analysis_outputs(root_folder: str) -> None:
         dfs.append(df)
 
     combined = pd.concat(dfs, ignore_index=True)
-    output_path = root / "experiment_overview.csv"
+
     combined.to_csv(output_path, index=False)
     print(f"Saved combined CSV to {output_path}")
 

{pykrait-0.3.0 → pykrait-0.3.1}/src/pykrait/io/images.py

@@ -7,6 +7,7 @@ from bioio import BioImage
 import bioio_tifffile
 import xml.etree.ElementTree as ET
 from skimage.measure import find_contours
+from scipy.ndimage import label
 
 ALLOWED_IMAGE_EXTENSIONS = [".czi", ".tif", ".tiff"]
 
@@ -159,6 +160,29 @@ def _reorder_dask_array(
 
     return dask_img.transpose(*perm)
 
+def read_image(
+    file_path: str,
+) -> np.ndarray:
+    """Reads a image from a file and returns it as a Dask array.
+
+    :param file_path: path to the image file
+    :type file_path: str
+    :return: Dask array of the 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 read_label_image(
     file_path: str,
@@ -175,9 +199,32 @@ def read_label_image(
 
     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)
+        img = img[0, 0, 0, :, :]
+        clean_masks = np.zeros_like(img)
+        roi_labels = np.unique(img)
+        roi_labels = roi_labels[roi_labels != 0]
+
+        # 8-way connectivity in 2D
+        kernel = np.ones((3, 3), dtype=bool)
+
+        for label_val in roi_labels:
+            roi_mask = img == label_val
+            labeled, n = label(roi_mask, structure=kernel)
+
+            # if mask is not connected
+            if n > 1:
+                component_sizes = np.bincount(labeled.ravel())[1:]
+                largest_idx = np.argmax(component_sizes) + 1
+                clean_masks[labeled == largest_idx] = label_val
+
+                warnings.warn(
+                    f"ROI {label_val} had {n} disconnected components — kept the largest ({component_sizes[largest_idx-1]} px).",
+                    UserWarning,
+                )
+            else:
+                clean_masks[roi_mask] = label_val
+        return clean_masks
+        
     except Exception as e:
         raise ValueError(
             f"Failed to read label image from {file_path}: {type(e).__name__}: {e}"

{pykrait-0.3.0 → pykrait-0.3.1}/src/pykrait/pipeline/pipeline.py

@@ -154,6 +154,10 @@ class AnalysisOutput:
     :vartype median_rise2080_s: float
     :var median_decay8020_s: median decay time from 80% to 20% of peak height in seconds
     :vartype median_decay8020_s: float
+    :var total_coinciding_peaks_1st_neighbour: total number of coinciding peaks between 1st degree neighbours
+    :vartype total_coinciding_peaks_1st_neighbour: int
+    :var possible_coinciding_peaks_1st_neighbour: total number of possible coinciding peaks between 1st degree neighbours
+    :vartype possible_coinciding_peaks_1st_neighbour: int
     :var random_1st_neighbour_zscore: z-score of synchronicity of the first neighbours in the random control
     :vartype random_1st_neighbour_zscore: float
     :var random_2nd_neighbour_zscore: z-score of synchronicity of the second neighbours in the random control
@@ -197,6 +201,8 @@ class AnalysisOutput:
     median_peakwidth_s: float = None
     median_rise2080_s: float = None
     median_decay8020_s: float = None
+    total_coinciding_peaks_1st_neighbour: int = None
+    possible_coinciding_peaks_1st_neighbour: int = None
     random_1st_neighbour_zscore: float = None
     random_2nd_neighbour_zscore: float = None
     random_3rd_neighbour_zscore: float = None
@@ -356,11 +362,11 @@ class CalciumVideo:
         )
 
         self.peak_series, peak_properties_df, peak_frame_nonzero, self.analysis_output = do_peak_analysis(
-            self.detrended_timeseries,
-            self.analysis_parameters,
-            self.analysis_output,
-            peak_min_width_frames,
-            peak_max_width_frames,
+            detrended_timeseries=self.detrended_timeseries,
+            peak_min_width_frames=peak_min_width_frames,
+            peak_max_width_frames=peak_max_width_frames,
+            analysis_parameters=self.analysis_parameters,
+            analysis_output=self.analysis_output,
         )
 
         self.analyis_output, self.experimental_stds, self.experimental_covs = (
@@ -672,7 +678,7 @@ def calculate_synchronicity(
     # calculate synchronicity for 1st, 2nd and 3rd degree neighbours
     frame_window = int(analysis_parameters.time_window / analysis_output.frame_interval)
     for neighbour_degree in [3, 2, 1]:
-        t_zscore, r_zscore, true_synchronous_peaks_matrix, rand_synchronous_peaks_matrix = (
+        t_zscore, r_zscore, true_synchronous_peaks_matrix, rand_synchronous_peaks_matrix, potential_synchronous_peaks_matrix = (
             calculate_synchronicity_zscore(
                 shortest_path_matrix,
                 peak_series,
@@ -682,6 +688,8 @@ def calculate_synchronicity(
             )
         )
         if neighbour_degree == 1:
+            analysis_output.total_coinciding_peaks_1st_neighbour = np.nansum(true_synchronous_peaks_matrix)
+            analysis_output.possible_coinciding_peaks_1st_neighbour = np.nansum(potential_synchronous_peaks_matrix)
             analysis_output.experiment_1st_neighbour_zscore = round(t_zscore, 2)
             analysis_output.random_1st_neighbour_zscore = round(r_zscore, 2)
         elif neighbour_degree == 2:

{pykrait-0.3.0 → pykrait-0.3.1}/src/pykrait/preprocessing/timeseries_extraction.py

@@ -14,7 +14,6 @@ from scipy.sparse.csgraph import floyd_warshall
 from scipy.spatial import KDTree
 from scipy.sparse import lil_matrix
 
-
 def _legacy_extract_mean_intensities(
     numpy_timelapse: np.ndarray, masks: np.ndarray
 ) -> np.ndarray:
@@ -112,37 +111,38 @@ def shrink_masks(masks: np.ndarray, shrink_factor: float = 0.7) -> np.ndarray:
     roi_labels = np.unique(masks)
     roi_labels = roi_labels[roi_labels != 0]  # skip background
 
+    # 8-way connectivity in 2D
+    kernel = np.ones((3, 3), dtype=bool)
+
     for label_val in roi_labels:
         roi_mask = masks == label_val
 
         # Compute erosion iterations based on area ratio
         area_original = roi_mask.sum()
         area_target = area_original * shrink_factor
+
+        if area_target < 20:
+            warnings.warn(f"ROI {label_val} too small to shrink — keeping original.", UserWarning)
+            shrunk_img[roi_mask] = label_val
+            continue
         radius_original = int(np.sqrt(area_original / np.pi))
         radius_target = int(np.sqrt(area_target / np.pi))
         iterations = max(radius_original - radius_target, 1)
 
         eroded_mask = binary_erosion(roi_mask, structure=disk(1), iterations=iterations)
-        shrunk_img[eroded_mask] = label_val
-
-    # Check that each ROI in the label image remains connected.
-    roi_labels = np.unique(shrunk_img)
-    roi_labels = roi_labels[roi_labels != 0]
-    for lbl in roi_labels:
-        roi_mask = shrunk_img == lbl
-        labeled, n = label(roi_mask)
-        if n > 1:
-            component_sizes = [np.sum(labeled == i) for i in range(1, n+1)]
-            warnings.warn(
-                f"During shrinking of labels, ROI {lbl} became disconnected into {n} components. "
-                f"Component sizes: {component_sizes}",
-                UserWarning,
-            )
 
-            for i, size in enumerate(component_sizes, start=1):
-                if size < 20:
-                    shrunk_img[labeled == i] = 0
-                    warnings.warn(f"Removed small component of ROI {lbl}: size = {size} pixels", UserWarning)
+        labeled, n = label(eroded_mask, structure=kernel)
+        if n > 1:
+                component_sizes = np.bincount(labeled.ravel())[1:]
+                largest_idx = np.argmax(component_sizes) + 1
+                shrunk_img[labeled == largest_idx] = label_val
+
+                warnings.warn(
+                    f"ROI {label_val} had {n} disconnected components — kept the largest ({component_sizes[largest_idx-1]} px).",
+                    UserWarning,
+                )
+        else:
+            shrunk_img[eroded_mask] = label_val
 
     return shrunk_img
 

{pykrait-0.3.0 → pykrait-0.3.1}/src/pykrait/trace_analysis/synchronicity.py

@@ -54,6 +54,49 @@ def find_synchronous_peaks(
 
     return synchronous_cells_matrix
 
+def find_possible_synchronous_peaks(
+    shortest_path_matrix: np.ndarray,
+    peak_series: np.ndarray,
+    neighbour_degree: int,
+    frame_window: int,
+) -> np.ndarray:
+    """
+    finds the number of possible synchronous peaks between connected cells given a certain neighbourhood degree and time window. 
+    This assumes that one peak can only be synchronous with one other peak from a connected cell, so the maximum number of synchronous 
+    events is limited by the cell with the fewer peaks.
+
+    :param shortest_path_matrix: ROI x ROI matrix with shortest path lengths between cells n and m
+    :type shortest_path_matrix: np.ndarray
+    :param peak_series: T x ROI binary matrix with 1s at calcium peak frames
+    :type peak_series: np.ndarray
+    :param neighbour_degree: degree of neighbourhood to consider (1 = direct neighbours)
+    :type neighbour_degree: int
+    :param frame_window: time window within peaks are considered synchronous
+    :type frame_window: int
+    :return: returns a ROI x ROI matrix with the number of possible synchronous peaks between connected cells
+    :rtype: np.ndarray
+    """
+    possible_synchronous_cells_matrix = np.zeros(shortest_path_matrix.shape, dtype=np.uint16)
+
+    # find connected cells
+    cell_indices = np.where(
+        shortest_path_matrix == neighbour_degree
+    )
+    if cell_indices[0].size == 0 or cell_indices[1].size == 0:
+        warnings.warn(f"No connected cell pairs found for the specified neighbour degree of {neighbour_degree}.", UserWarning)
+        return possible_synchronous_cells_matrix
+
+    n_peaks_per_cell = np.sum(peak_series, axis=0)
+
+    for synchronous_cellpair in range(0, cell_indices[0].shape[0]):
+        possible_synchronous_cells_matrix[
+            cell_indices[0][synchronous_cellpair], cell_indices[1][synchronous_cellpair]
+        ] = min(
+            n_peaks_per_cell[cell_indices[0][synchronous_cellpair]],
+            n_peaks_per_cell[cell_indices[1][synchronous_cellpair]],
+        )
+
+    return possible_synchronous_cells_matrix
 
 def _random_synchronous_peaks(
     shortest_path_matrix: np.ndarray,
@@ -106,7 +149,7 @@ def calculate_synchronicity_zscore(
     neighbour_degree: int,
     frame_window: int,
     n_iter=100,
-) -> Tuple[float, float, np.ndarray, np.ndarray]:
+) -> Tuple[float, float, np.ndarray, np.ndarray, np.ndarray]:
     """
     calculates the zscore of the synchronicity between connected cells given a certain neighbourhood degree and time window.
 
@@ -120,8 +163,8 @@ def calculate_synchronicity_zscore(
     :type frame_window: int
     :param n_iter: number of random permutations to bootstrap against, defaults to 100
     :type n_iter: int, optional
-    :return: returns the zscore of the synchronicity, the true synchronous peaks matrix and one example random synchronous peaks matrix
-    :rtype: Tuple[float, float, np.ndarray, np.ndarray]
+    :return: returns the zscore of the synchronicity, the true synchronous peaks matrix, one example random synchronous peaks matrix and the possible synchronous peaks matrix
+    :rtype: Tuple[float, float, np.ndarray, np.ndarray, np.ndarray]
     """
     # finds true connected peaks
     true_synchronous_peaks_matrix = find_synchronous_peaks(
@@ -148,9 +191,14 @@ def calculate_synchronicity_zscore(
     true_synchronicity_zscore = (true_synchronous_peaks - np.mean(rand_synchronous_peaks)) / np.std(rand_synchronous_peaks)
     rand_synchronicity_zscore = (rand_synchronous_peaks[0] - np.mean(rand_synchronous_peaks)) / np.std(rand_synchronous_peaks)
 
+    # calculate possible synchronous peaks matrices
+    potential_synchronous_peaks_matrix = find_possible_synchronous_peaks(
+        shortest_path_matrix, peak_series, neighbour_degree, frame_window
+    )
     return (
         true_synchronicity_zscore,
         rand_synchronicity_zscore,
         true_synchronous_peaks_matrix,
         rand_synchronous_peaks_matrix[0, :, :],
+        potential_synchronous_peaks_matrix
     )

{pykrait-0.3.0 → pykrait-0.3.1}/src/pykrait/visualization/image_overlays.py

@@ -105,7 +105,12 @@ def create_synchronicity_image(tproj:np.ndarray, masks:np.ndarray, synchronous_p
     :type savepath: str, optional
     :return: _description_
     :rtype: Figure
-    """    
+    """
+    if tproj.ndim >= 2:
+        tproj = tproj.squeeze()
+        if tproj.ndim != 2:
+            raise ValueError(f"tproj must be a 2D array, not of shape {tproj.shape}.")    
+    
     fig, ax = plt.subplots()
     ax.imshow(tproj, cmap='gray')