lbm_caiman_python 0.2.0__py3-none-any.whl

lbm_caiman_python/default_ops.py

@@ -0,0 +1,92 @@
+"""
+default caiman parameters for lbm data processing.
+"""
+
+
+def default_ops() -> dict:
+    """
+    return default caiman parameters optimized for lbm microscopy data.
+
+    returns
+    -------
+    dict
+        dictionary of parameters for motion correction and cnmf.
+    """
+    return {
+        # motion correction parameters
+        "do_motion_correction": True,
+        "max_shifts": (6, 6),
+        "strides": (48, 48),
+        "overlaps": (24, 24),
+        "max_deviation_rigid": 3,
+        "pw_rigid": True,
+        "gSig_filt": (2, 2),
+        "border_nan": "copy",
+        "niter_rig": 1,
+        "splits_rig": 14,
+        "num_splits_to_process_rig": None,
+        "splits_els": 14,
+        "num_splits_to_process_els": None,
+        "upsample_factor_grid": 4,
+        "max_deviation_rigid": 3,
+        "use_cuda": False,
+
+        # cnmf parameters
+        "do_cnmf": True,
+        "K": 50,
+        "gSig": (4, 4),
+        "gSiz": None,
+        "p": 1,
+        "merge_thresh": 0.8,
+        "min_SNR": 2.5,
+        "rval_thr": 0.85,
+        "decay_time": 0.4,
+        "method_init": "greedy_roi",
+        "ssub": 1,
+        "tsub": 1,
+        "rf": None,
+        "stride": None,
+        "nb": 1,
+        "gnb": 1,
+        "low_rank_background": True,
+        "update_background_components": True,
+        "rolling_sum": True,
+        "only_init": False,
+        "normalize_init": True,
+        "ring_size_factor": 1.5,
+
+        # component evaluation
+        "min_cnn_thr": 0.9,
+        "cnn_lowest": 0.1,
+        "use_cnn": False,
+
+        # general parameters
+        "fr": 30.0,
+        "n_processes": None,
+        "dxy": (1.0, 1.0),
+    }
+
+
+def mcorr_ops() -> dict:
+    """return only motion correction parameters."""
+    ops = default_ops()
+    return {k: v for k, v in ops.items() if k in (
+        "do_motion_correction", "max_shifts", "strides", "overlaps",
+        "max_deviation_rigid", "pw_rigid", "gSig_filt", "border_nan",
+        "niter_rig", "splits_rig", "num_splits_to_process_rig",
+        "splits_els", "num_splits_to_process_els", "upsample_factor_grid",
+        "use_cuda", "fr", "n_processes", "dxy",
+    )}
+
+
+def cnmf_ops() -> dict:
+    """return only cnmf parameters."""
+    ops = default_ops()
+    return {k: v for k, v in ops.items() if k in (
+        "do_cnmf", "K", "gSig", "gSiz", "p", "merge_thresh", "min_SNR",
+        "rval_thr", "decay_time", "method_init", "ssub", "tsub", "rf",
+        "stride", "nb", "gnb", "low_rank_background",
+        "update_background_components", "rolling_sum", "only_init",
+        "normalize_init", "ring_size_factor", "min_cnn_thr", "cnn_lowest",
+        "use_cnn", "fr", "n_processes", "dxy",
+    )}

lbm_caiman_python/gui/__init__.py

@@ -0,0 +1,3 @@
+from .rungui import run_gui
+
+__all__ = ['run_gui']

lbm_caiman_python/gui/_store_model.py

@@ -0,0 +1,170 @@
+from typing import *
+import numpy as np
+from fastplotlib import ImageGraphic, LinearSelector, ScatterGraphic, ImageWidget
+from ipywidgets import IntSlider, FloatSlider
+
+from fastplotlib.graphics._features import FeatureEvent
+
+MARGIN: float = 1
+
+
+# TODO: need to make a method for automatic MARGIN setting based on the data
+
+
+class TimeStoreComponent:
+    @property
+    def subscriber(self) -> ImageGraphic | IntSlider | FloatSlider | LinearSelector:
+        return self._subscriber
+
+    @property
+    def data(self) -> np.ndarray | None:
+        return self._data
+
+    @property
+    def multiplier(self) -> int | float | None:
+        return self._multiplier
+
+    @property
+    def data_filter(self) -> callable:
+        return self._data_filter
+
+    def __init__(self, subscriber, data=None, data_filter=None, multiplier=None):
+        """A TimeStore component of the time store."""
+        if multiplier is None:
+            multiplier = 1
+
+        self._multiplier = multiplier
+
+        self._subscriber = subscriber
+
+        # must have data if ImageGraphic
+        if isinstance(self.subscriber, (ImageGraphic, ScatterGraphic)):
+            # LazyArrayRCM has no `__array__`, using `shape` for now
+            if not hasattr(data, 'shape'):
+                raise ValueError("If passing in `ImageGraphic` must provide associated `ndarray` object to update "
+                                 "data with.")
+            self._data = data
+        self._data_filter = data_filter
+
+
+class TimeStore:
+    @property
+    def time(self):
+        """Current t value that items in the store are set at."""
+        return self._time
+
+    @time.setter
+    def time(self, value: int | float):
+        """Set the current time."""
+        self._time = int(value)
+
+    @property
+    def store(self) -> List[TimeStoreComponent]:
+        """Returns the items in the store."""
+        return self._store
+
+    def __init__(self):
+        """
+        TimeStore for synchronizes and updating components of a plot (i.e. Ipywidgets.IntSlider,
+        fastplotlib.LinearSelector, or fastplotlob.ImageGraphic).
+
+        NOTE: If passing a `fastplotlib.ImageGraphic`, it is understood that there should be an associated
+        `ndarray` given.
+        """
+        # initialize store
+        self._store = list()
+        # by default, time is zero
+        self._time = 0
+
+    def subscribe(self,
+                  subscriber: ImageWidget | ImageGraphic | LinearSelector | ScatterGraphic | IntSlider | FloatSlider,
+                  data: np.ndarray = None,
+                  data_filter: callable = None,
+                  multiplier: int | float = None) -> None:
+        """
+        Method for adding a subscriber to the store to be synchronized.
+
+        Parameters
+        ----------
+        subscriber: fastplotlib.ImageGraphic, fastplotlib.LinearSelector, ipywidgets.IntSlider, or ipywidgets.FloatSlider
+            ipywidget or fastplotlib object to be synchronized
+        data: np.ndarray, optional
+            If subscriber is a fastplotlib.ImageGraphic, must have an associating numpy.ndarray to update data with.
+        data_filter: callable, optional
+            Function to apply to data before updating. Must return data in the same shape as input.
+        multiplier: int | float, optional
+            Scale the current time to reflect differing timescale.
+        """
+        # create a TimeStoreComponent
+        component = TimeStoreComponent(subscriber=subscriber,
+                                       data=data,
+                                       data_filter=data_filter,
+                                       multiplier=multiplier)
+
+        # add component to the store
+        self._store.append(component)
+
+        if isinstance(component.subscriber, ImageWidget):
+            component.subscriber.add_event_handler(self._update_store, "current_index")
+        if isinstance(component.subscriber, (IntSlider, FloatSlider)):
+            component.subscriber.observe(self._update_store, "value")
+        if isinstance(component.subscriber, LinearSelector):
+            component.subscriber.add_event_handler(self._update_store, "selection")
+
+    def unsubscribe(self, subscriber: ImageGraphic | LinearSelector | IntSlider | FloatSlider):
+        """Remove a subscriber from the store."""
+        for component in self.store:
+            if component.subscriber == subscriber:
+                #  remove the component from the store
+                self.store.remove(component)
+                # remove event handler
+                if isinstance(component, (IntSlider, FloatSlider)):
+                    component.unobserve(self._update_store)
+                if isinstance(component, LinearSelector):
+                    component.subscriber.remove_event_handler(self._update_store, "selection")
+
+    def _update_store(self, ev):
+        """Called when event occurs and store needs to be updated."""
+        # parse event to see if it originated from ipywidget or selector
+        if isinstance(ev, FeatureEvent):
+            # check for multiplier to adjust time
+            for component in self.store:
+                if isinstance(component.subscriber, LinearSelector):
+                    if ev.graphic == component.subscriber:
+                        self.time = ev.info["value"] / component.multiplier
+        elif isinstance(ev, dict):
+            self.time = ev["t"]
+        else:
+            self.time = ev["new"]
+
+        print('Iterating components')
+        for component in self.store:
+            print('Component 1')
+            if isinstance(component.subscriber, ImageWidget):
+                # user moved qslider, don't update imagewidget
+                if isinstance(ev, dict) and 't' in ev:
+                    pass
+                else:
+                    component.subscriber.current_index = {"t": self.time}
+            elif isinstance(component.subscriber, ScatterGraphic):
+                component.subscriber.data = component.data[self.time]
+            # update ImageGraphic data no matter what
+            elif isinstance(component.subscriber, ImageGraphic):
+                if component.data_filter is None:
+                    new_data = component.data[self.time]
+                else:
+                    new_data = component.data_filter(component.data[self.time])
+                if new_data.shape != component.subscriber.data.value.shape:
+                    raise ValueError(f"data filter function: {component.data_filter} must return data in the same shape"
+                                     f"as the current data")
+                component.subscriber.data = new_data
+            elif isinstance(component.subscriber, LinearSelector):
+                # only update if different
+                if abs(component.subscriber.selection - (self.time * component.multiplier)) > MARGIN:
+                    print('Is LinearSelector and abs(component.subscriber.selection - (self.time * '
+                          'component.multiplier)) > MARGIN')
+                    component.subscriber.selection = self.time * component.multiplier
+            else:
+                # only update if different
+                if abs(component.subscriber.value - self.time) > MARGIN:
+                    component.subscriber.value = self.time

lbm_caiman_python/gui/rungui.py

@@ -0,0 +1,13 @@
+import sys
+
+from qtpy.QtWidgets import QApplication
+from lbm_caiman_python.gui.widgets import LBMMainWindow
+
+
+def run_gui(path):
+    app = QApplication(sys.argv)
+    main_window = LBMMainWindow()
+    print('--')
+    main_window.show()
+    app.exec()
+    # fpl.loop.run()

lbm_caiman_python/gui/widgets.py

@@ -0,0 +1,114 @@
+import webbrowser
+
+from pathlib import Path
+
+import numpy as np
+from qtpy.QtWidgets import QMainWindow, QFileDialog
+from qtpy import QtGui, QtCore
+import fastplotlib as fpl
+from fastplotlib.ui import EdgeWindow
+
+from mbo_utilities import get_files, imread
+
+try:
+    from imgui_bundle import imgui, icons_fontawesome_6 as fa
+except ImportError:
+    raise ImportError("Please install imgui via `conda install -c conda-forge imgui-bundle`")
+
+
+def get_base_iw():
+    """Temp until I figure out how to start with an empty canvas"""
+    rand = np.random.randn(100, 100, 100)
+    iw = fpl.ImageWidget(rand, histogram_widget=False)
+    return iw
+
+
+def get_iw(path):
+    files = get_files(path, "plane", 1)
+    arr = imread(files)
+    iw = fpl.ImageWidget(arr, histogram_widget=False)
+    return iw
+
+
+class LBMMainWindow(QMainWindow):
+
+    @property
+    def image_widget(self):
+        return self._image_widget
+
+    def __init__(self):
+        super(LBMMainWindow, self).__init__()
+
+        print('Setting up main window')
+        self.setGeometry(50, 50, 1500, 800)
+        self.setWindowTitle("LBM-CaImAn-Python Pipeline")
+
+        app_icon = QtGui.QIcon()
+        icon_path = str(Path().home() / ".lbm" / "icons" / "icon_caiman_python.svg")
+        app_icon.addFile(icon_path, QtCore.QSize(16, 16))
+        app_icon.addFile(icon_path, QtCore.QSize(24, 24))
+        app_icon.addFile(icon_path, QtCore.QSize(32, 32))
+        app_icon.addFile(icon_path, QtCore.QSize(48, 48))
+        app_icon.addFile(icon_path, QtCore.QSize(64, 64))
+        app_icon.addFile(icon_path, QtCore.QSize(256, 256))
+        self.setWindowIcon(app_icon)
+        self.setStyleSheet("QMainWindow {background: 'black';}")
+        self.stylePressed = ("QPushButton {Text-align: left; "
+                             "background-color: rgb(100,50,100); "
+                             "color:white;}")
+        self.styleUnpressed = ("QPushButton {Text-align: left; "
+                               "background-color: rgb(50,50,50); "
+                               "color:white;}")
+        self.styleInactive = ("QPushButton {Text-align: left; "
+                              "background-color: rgb(50,50,50); "
+                              "color:gray;}")
+
+        print('Setting up image widget')
+        self._image_widget = get_base_iw()
+        gui = PreviewTracesWidget(size=50)
+        self._image_widget.figure.add_gui(gui)
+        qwidget = self._image_widget.show()
+        self.setCentralWidget(qwidget)
+        self.resize(1200, 800)
+
+
+class PreviewTracesWidget(EdgeWindow):
+    def __init__(self, figure, size, location, title, image_widget):
+        super().__init__(figure=figure, size=size, location=location, title=title)
+        self._image_widget = image_widget
+
+        # whether or not a dimension is in play mode
+        self._playing: dict[str, bool] = {"t": False, "z": False}
+
+        self.tfig = fpl.Figure()
+
+        self.raw_trace = self.tfig[0, 0].add_line(np.zeros(self._image_widget.data[0].shape[0]))
+        self._image_widget.managed_graphics[0].add_event_handler("click")
+        self.tfig.show()
+
+    def pixel_clicked(self, ev):
+        col, row = ev.pick_info["index"]
+        if self._image_widget.ndim == 4:
+            self.raw_trace.data[:, 1] = self._image_widget.data[0][:, self._image_widget.current_index["z"], row, col]
+        elif self._image_widget.ndim == 3:
+            self.raw_trace.data[:, 1] = self._image_widget.data[0][:, row, col]
+        else:
+            raise ValueError("ImageWidget has an unexpected number of dimensions. Expected 3 or 4.")
+        self.tfig[0, 0].auto_scale(maintain_aspect=False)
+
+    def update(self):
+
+        imgui.push_font(self._fa_icons)
+        if imgui.button(label=fa.ICON_FA_FOLDER_OPEN):
+            print("Opening file dialog")
+            dlg_kwargs = {
+                "parent": self.parent,
+                "caption": "Open folder with z-planes",
+            }
+            name = QFileDialog.getExistingDirectory(**dlg_kwargs)
+            print(name)
+            self.parent.update_widget(name)
+
+        imgui.pop_font()
+        if imgui.is_item_hovered(0):
+            imgui.set_tooltip("Open a file dialog to load data")

lbm_caiman_python/helpers.py

@@ -0,0 +1,262 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from typing import Any as ArrayLike
+
+
+def _get_30p_order():
+    return (np.array([
+        1, 5, 6, 7, 8, 9, 2, 10, 11, 12, 13, 14, 15, 16, 17, 3, 18, 19, 20, 21, 22, 23, 4, 24, 25, 26, 27, 28, 29, 30
+    ]) - 1)
+
+
+def extract_center_square(images, size):
+    """
+    Extract a square crop from the center of the input images.
+
+    Parameters
+    ----------
+    images : numpy.ndarray
+        Input array. Can be 2D (H x W) or 3D (T x H x W), where:
+        - H is the height of the image(s).
+        - W is the width of the image(s).
+        - T is the number of frames (if 3D).
+    size : int
+        The size of the square crop. The output will have dimensions
+        (size x size) for 2D inputs or (T x size x size) for 3D inputs.
+
+    Returns
+    -------
+    numpy.ndarray
+        A square crop from the center of the input images. The returned array
+        will have dimensions:
+        - (size x size) if the input is 2D.
+        - (T x size x size) if the input is 3D.
+
+    Raises
+    ------
+    ValueError
+        If `images` is not a NumPy array.
+        If `images` is not 2D or 3D.
+        If the specified `size` is larger than the height or width of the input images.
+
+    Notes
+    -----
+    - For 2D arrays, the function extracts a square crop directly from the center.
+    - For 3D arrays, the crop is applied uniformly across all frames (T).
+    - If the input dimensions are smaller than the requested `size`, an error will be raised.
+
+    Examples
+    --------
+    Extract a center square from a 2D image:
+
+    >>> import numpy as np
+    >>> image = np.random.rand(600, 576)
+    >>> cropped = extract_center_square(image, size=200)
+    >>> cropped.shape
+    (200, 200)
+
+    Extract a center square from a 3D stack of images:
+
+    >>> stack = np.random.rand(100, 600, 576)
+    >>> cropped_stack = extract_center_square(stack, size=200)
+    >>> cropped_stack.shape
+    (100, 200, 200)
+    """
+    if not isinstance(images, np.ndarray):
+        raise ValueError("Input must be a numpy array.")
+
+    if images.ndim == 2:  # 2D array (H x W)
+        height, width = images.shape
+        center_h, center_w = height // 2, width // 2
+        half_size = size // 2
+        return images[center_h - half_size:center_h + half_size,
+               center_w - half_size:center_w + half_size]
+
+    elif images.ndim == 3:  # 3D array (T x H x W)
+        T, height, width = images.shape
+        center_h, center_w = height // 2, width // 2
+        half_size = size // 2
+        return images[:,
+               center_h - half_size:center_h + half_size,
+               center_w - half_size:center_w + half_size]
+    else:
+        raise ValueError("Input array must be 2D or 3D.")
+
+def _get_30p_order():
+    return (np.array([
+        1, 5, 6, 7, 8, 9, 2, 10, 11, 12, 13, 14, 15, 16, 17, 3, 18, 19, 20, 21, 22, 23, 4, 24, 25, 26, 27, 28, 29, 30
+    ]) - 1)
+
+
+def extract_center_square(images, size):
+    """
+    Extract a square crop from the center of the input images.
+
+    Parameters
+    ----------
+    images : numpy.ndarray
+        Input array. Can be 2D (H x W) or 3D (T x H x W), where:
+        - H is the height of the image(s).
+        - W is the width of the image(s).
+        - T is the number of frames (if 3D).
+    size : int
+        The size of the square crop. The output will have dimensions
+        (size x size) for 2D inputs or (T x size x size) for 3D inputs.
+
+    Returns
+    -------
+    numpy.ndarray
+        A square crop from the center of the input images. The returned array
+        will have dimensions:
+        - (size x size) if the input is 2D.
+        - (T x size x size) if the input is 3D.
+
+    Raises
+    ------
+    ValueError
+        If `images` is not a NumPy array.
+        If `images` is not 2D or 3D.
+        If the specified `size` is larger than the height or width of the input images.
+
+    Notes
+    -----
+    - For 2D arrays, the function extracts a square crop directly from the center.
+    - For 3D arrays, the crop is applied uniformly across all frames (T).
+    - If the input dimensions are smaller than the requested `size`, an error will be raised.
+
+    Examples
+    --------
+    Extract a center square from a 2D image:
+
+    >>> import numpy as np
+    >>> image = np.random.rand(600, 576)
+    >>> cropped = extract_center_square(image, size=200)
+    >>> cropped.shape
+    (200, 200)
+
+    Extract a center square from a 3D stack of images:
+
+    >>> stack = np.random.rand(100, 600, 576)
+    >>> cropped_stack = extract_center_square(stack, size=200)
+    >>> cropped_stack.shape
+    (100, 200, 200)
+    """
+    if not isinstance(images, np.ndarray):
+        raise ValueError("Input must be a numpy array.")
+
+    if images.ndim == 2:  # 2D array (H x W)
+        height, width = images.shape
+        center_h, center_w = height // 2, width // 2
+        half_size = size // 2
+        return images[center_h - half_size:center_h + half_size,
+               center_w - half_size:center_w + half_size]
+
+    elif images.ndim == 3:  # 3D array (T x H x W)
+        T, height, width = images.shape
+        center_h, center_w = height // 2, width // 2
+        half_size = size // 2
+        return images[:,
+               center_h - half_size:center_h + half_size,
+               center_w - half_size:center_w + half_size]
+    else:
+        raise ValueError("Input array must be 2D or 3D.")
+
+
+def get_single_patch_coords(dims, stride, overlap, patch_index):
+    """
+    Get coordinates of a single patch based on stride, overlap parameters of motion-correction.
+
+    Parameters
+    ----------
+    dims : tuple
+        Dimensions of the image as (rows, cols).
+    stride : int
+        Number of pixels to include in each patch.
+    overlap : int
+        Number of pixels to overlap between patches.
+    patch_index : tuple
+        Index of the patch to return.
+    """
+    patch_height = stride + overlap
+    patch_width = stride + overlap
+    rows = np.arange(0, dims[0] - patch_height + 1, stride)
+    cols = np.arange(0, dims[1] - patch_width + 1, stride)
+
+    row_idx, col_idx = patch_index
+    y_start = rows[row_idx]
+    x_start = cols[col_idx]
+
+    return y_start, y_start + patch_height, x_start, x_start + patch_width
+
+
+def _pad_image_for_even_patches(image, stride, overlap):
+    patch_width = stride + overlap
+    padded_x = int(np.ceil(image.shape[0] / patch_width) * patch_width) - image.shape[0]
+    padded_y = int(np.ceil(image.shape[1] / patch_width) * patch_width) - image.shape[1]
+    return np.pad(image, ((0, padded_x), (0, padded_y)), mode='constant'), padded_x, padded_y
+
+
+def generate_patch_view(image: ArrayLike, pixel_resolution: float, target_patch_size: int = 40,
+                        overlap_fraction: float = 0.5):
+    """
+    Generate a patch visualization for a 2D image with approximately square patches of a specified size in microns.
+    Patches are evenly distributed across the image, using calculated strides and overlaps.
+
+    Parameters
+    ----------
+    image : ndarray
+        A 2D NumPy array representing the input image to be divided into patches.
+    pixel_resolution : float
+        The pixel resolution of the image in microns per pixel.
+    target_patch_size : float, optional
+        The desired size of the patches in microns. Default is 40 microns.
+    overlap_fraction : float, optional
+        The fraction of the patch size to use as overlap between patches. Default is 0.5 (50%).
+
+    Returns
+    -------
+    fig : matplotlib.figure.Figure
+        A matplotlib figure containing the patch visualization.
+    ax : matplotlib.axes.Axes
+        A matplotlib axes object showing the patch layout on the image.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from matplotlib import pyplot as plt
+    >>> data = np.random.random((144, 600))  # Example 2D image
+    >>> pixel_resolution = 0.5  # Microns per pixel
+    >>> fig, ax = generate_patch_view(data, pixel_resolution)
+    >>> plt.show()
+    """
+
+    from caiman.utils.visualization import get_rectangle_coords, rect_draw
+
+    # Calculate stride and overlap in pixels
+    stride = int(target_patch_size / pixel_resolution)
+    overlap = int(overlap_fraction * stride)
+
+    # pad the image like caiman does
+    def pad_image_for_even_patches(image, stride, overlap):
+        patch_width = stride + overlap
+        padded_x = int(np.ceil(image.shape[0] / patch_width) * patch_width) - image.shape[0]
+        padded_y = int(np.ceil(image.shape[1] / patch_width) * patch_width) - image.shape[1]
+        return np.pad(image, ((0, padded_x), (0, padded_y)), mode='constant'), padded_x, padded_y
+
+    padded_image, pad_x, pad_y = pad_image_for_even_patches(image, stride, overlap)
+
+    # Get patch coordinates
+    patch_rows, patch_cols = get_rectangle_coords(padded_image.shape, stride, overlap)
+
+    fig, ax = plt.subplots(figsize=(8, 8))
+    ax.imshow(padded_image, cmap='gray')
+
+    # Draw patches using rect_draw
+    for patch_row in patch_rows:
+        for patch_col in patch_cols:
+            rect_draw(patch_row, patch_col, color='white', alpha=0.2, ax=ax)
+
+    ax.set_title(f"Stride: {stride} pixels (~{stride * pixel_resolution:.1f} μm)\n"
+                 f"Overlap: {overlap} pixels (~{overlap * pixel_resolution:.1f} μm)\n")
+    plt.tight_layout()
+    return fig, ax, stride, overlap