exhale-lung 1.3.0__tar.gz

exhale_lung-1.3.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Carl Troein, Tom Delaire, Bryan Falcones, Emanuel Larsson, Karina Thånell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

exhale_lung-1.3.0/MANIFEST.in

@@ -0,0 +1,21 @@
+include README.md
+include README.md
+include pyproject.toml
+include MANIFEST.in
+include run_exhale.py
+
+recursive-include exhale *.py
+recursive-include exhale/resources/icons *.png *.svg
+recursive-include exhale/resources/models *.json *.h5
+
+exclude .gitignore
+exclude win_build.py
+
+prune .github
+prune build
+prune dist
+prune packaging
+prune exhale.egg-info
+prune exhale/resources/ui
+
+global-exclude __pycache__ *.py[cod]

exhale_lung-1.3.0/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: exhale-lung
+Version: 1.3.0
+Summary: EXHALE, Efficient X-ray Hub Aiding Lung Explorations
+Author: Tom Delaire, Emanuel Larsson, Bryan Falcones, Karina Thånell
+Author-email: Carl Troein <carl.troein@cec.lu.se>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ctroein/exhale
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: scikit-learn
+Requires-Dist: pandas
+Requires-Dist: h5py
+Requires-Dist: napari
+Requires-Dist: imageio
+Requires-Dist: silx
+Requires-Dist: csbdeep
+Requires-Dist: pyqt5
+Requires-Dist: tensorflow==2.15.*; sys_platform == "win32"
+Requires-Dist: tensorflow; sys_platform != "win32"
+Requires-Dist: stardist
+Dynamic: license-file
+
+# EXHALE
+## Efficient X-ray Hub Aiding Lung Explorations
+
+This project aims to develop a specialized tool for investigating elemental aspects of chronic lung diseases. 
+
+From the [VINNOVA project
+description](https://www.vinnova.se/en/p/exhale--efficient-x-ray-hub-aiding-lung-explorations/):  
+The purpose of this project is to advance understanding and treatment of
+chronic lung diseases, leading causes of mortality worldwide, by
+characterizing elements in lung tissue suspected to impact their
+pathogenesis. The industrial partners TrulyLabs and AnaMar in collaboration
+with MAX IV, Lung Biology and Correlative Image Processing and Analysis
+(CIPA) fom Lund University, aim to streamline a workflow of X-ray imaging
+studies for lung diseases, making these methods more accessible for
+biomedical companies and clinical researchers.
+
+## Currect functionality
+
+* Loading HDF5 files with XRF data from the NanoMAX beamline at MAX IV.
+* Composing element maps into publication-ready figures.
+* Segmentation of cells and clustering of areas in element maps.

exhale_lung-1.3.0/README.md

@@ -0,0 +1,21 @@
+# EXHALE
+## Efficient X-ray Hub Aiding Lung Explorations
+
+This project aims to develop a specialized tool for investigating elemental aspects of chronic lung diseases. 
+
+From the [VINNOVA project
+description](https://www.vinnova.se/en/p/exhale--efficient-x-ray-hub-aiding-lung-explorations/):  
+The purpose of this project is to advance understanding and treatment of
+chronic lung diseases, leading causes of mortality worldwide, by
+characterizing elements in lung tissue suspected to impact their
+pathogenesis. The industrial partners TrulyLabs and AnaMar in collaboration
+with MAX IV, Lung Biology and Correlative Image Processing and Analysis
+(CIPA) fom Lund University, aim to streamline a workflow of X-ray imaging
+studies for lung diseases, making these methods more accessible for
+biomedical companies and clinical researchers.
+
+## Currect functionality
+
+* Loading HDF5 files with XRF data from the NanoMAX beamline at MAX IV.
+* Composing element maps into publication-ready figures.
+* Segmentation of cells and clustering of areas in element maps.

exhale_lung-1.3.0/exhale/__init__.py

@@ -0,0 +1,8 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed May 29 12:23:17 2024
+
+@author: carl
+"""
+

exhale_lung-1.3.0/exhale/__main__.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from .exhale import main
+
+if __name__ == "__main__":
+    main()

exhale_lung-1.3.0/exhale/analysisdialog.py

@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file 'analysisdialog.ui'
+#
+# Created by: PyQt5 UI code generator 5.15.9
+#
+# WARNING: Any manual changes made to this file will be lost when pyuic5 is
+# run again.  Do not edit this file unless you know what you are doing.
+
+
+from PyQt5 import QtCore, QtGui, QtWidgets
+
+
+class Ui_AnalysisDialog(object):
+    def setupUi(self, AnalysisDialog):
+        AnalysisDialog.setObjectName("AnalysisDialog")
+        AnalysisDialog.resize(415, 314)
+        self.verticalLayout = QtWidgets.QVBoxLayout(AnalysisDialog)
+        self.verticalLayout.setObjectName("verticalLayout")
+        self.horizontalLayout_6 = QtWidgets.QHBoxLayout()
+        self.horizontalLayout_6.setObjectName("horizontalLayout_6")
+        self.label_2 = QtWidgets.QLabel(AnalysisDialog)
+        self.label_2.setObjectName("label_2")
+        self.horizontalLayout_6.addWidget(self.label_2)
+        self.clusterMinK = QtWidgets.QSpinBox(AnalysisDialog)
+        self.clusterMinK.setMinimum(1)
+        self.clusterMinK.setStepType(QtWidgets.QAbstractSpinBox.AdaptiveDecimalStepType)
+        self.clusterMinK.setProperty("value", 3)
+        self.clusterMinK.setObjectName("clusterMinK")
+        self.horizontalLayout_6.addWidget(self.clusterMinK)
+        self.label_10 = QtWidgets.QLabel(AnalysisDialog)
+        self.label_10.setObjectName("label_10")
+        self.horizontalLayout_6.addWidget(self.label_10)
+        self.clusterMaxK = QtWidgets.QSpinBox(AnalysisDialog)
+        self.clusterMaxK.setMinimum(1)
+        self.clusterMaxK.setMaximum(999)
+        self.clusterMaxK.setStepType(QtWidgets.QAbstractSpinBox.AdaptiveDecimalStepType)
+        self.clusterMaxK.setProperty("value", 10)
+        self.clusterMaxK.setObjectName("clusterMaxK")
+        self.horizontalLayout_6.addWidget(self.clusterMaxK)
+        self.horizontalLayout_6.setStretch(0, 1)
+        self.horizontalLayout_6.setStretch(1, 1)
+        self.horizontalLayout_6.setStretch(3, 1)
+        self.verticalLayout.addLayout(self.horizontalLayout_6)
+        self.horizontalLayout = QtWidgets.QHBoxLayout()
+        self.horizontalLayout.setObjectName("horizontalLayout")
+        self.label = QtWidgets.QLabel(AnalysisDialog)
+        self.label.setObjectName("label")
+        self.horizontalLayout.addWidget(self.label)
+        self.clusterNInit = QtWidgets.QSpinBox(AnalysisDialog)
+        self.clusterNInit.setMinimum(1)
+        self.clusterNInit.setMaximum(999)
+        self.clusterNInit.setStepType(QtWidgets.QAbstractSpinBox.AdaptiveDecimalStepType)
+        self.clusterNInit.setProperty("value", 50)
+        self.clusterNInit.setObjectName("clusterNInit")
+        self.horizontalLayout.addWidget(self.clusterNInit)
+        self.horizontalLayout.setStretch(0, 2)
+        self.horizontalLayout.setStretch(1, 1)
+        self.verticalLayout.addLayout(self.horizontalLayout)
+        self.gridLayout = QtWidgets.QGridLayout()
+        self.gridLayout.setObjectName("gridLayout")
+        self.label_3 = QtWidgets.QLabel(AnalysisDialog)
+        self.label_3.setObjectName("label_3")
+        self.gridLayout.addWidget(self.label_3, 0, 0, 1, 1)
+        self.label_4 = QtWidgets.QLabel(AnalysisDialog)
+        self.label_4.setObjectName("label_4")
+        self.gridLayout.addWidget(self.label_4, 0, 2, 1, 1)
+        self.nucleiExpansion = QtWidgets.QSpinBox(AnalysisDialog)
+        self.nucleiExpansion.setMinimum(1)
+        self.nucleiExpansion.setMaximum(999)
+        self.nucleiExpansion.setStepType(QtWidgets.QAbstractSpinBox.AdaptiveDecimalStepType)
+        self.nucleiExpansion.setProperty("value", 15)
+        self.nucleiExpansion.setObjectName("nucleiExpansion")
+        self.gridLayout.addWidget(self.nucleiExpansion, 0, 1, 1, 1)
+        self.label_5 = QtWidgets.QLabel(AnalysisDialog)
+        self.label_5.setObjectName("label_5")
+        self.gridLayout.addWidget(self.label_5, 1, 0, 1, 1)
+        self.nucleiMinArea = QtWidgets.QSpinBox(AnalysisDialog)
+        self.nucleiMinArea.setMinimum(1)
+        self.nucleiMinArea.setMaximum(999)
+        self.nucleiMinArea.setStepType(QtWidgets.QAbstractSpinBox.AdaptiveDecimalStepType)
+        self.nucleiMinArea.setProperty("value", 100)
+        self.nucleiMinArea.setObjectName("nucleiMinArea")
+        self.gridLayout.addWidget(self.nucleiMinArea, 1, 1, 1, 1)
+        self.label_6 = QtWidgets.QLabel(AnalysisDialog)
+        self.label_6.setObjectName("label_6")
+        self.gridLayout.addWidget(self.label_6, 1, 2, 1, 1)
+        self.gridLayout.setColumnStretch(0, 2)
+        self.gridLayout.setColumnStretch(1, 1)
+        self.verticalLayout.addLayout(self.gridLayout)
+        spacerItem = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
+        self.verticalLayout.addItem(spacerItem)
+        self.buttonBox = QtWidgets.QDialogButtonBox(AnalysisDialog)
+        self.buttonBox.setOrientation(QtCore.Qt.Horizontal)
+        self.buttonBox.setStandardButtons(QtWidgets.QDialogButtonBox.Close)
+        self.buttonBox.setObjectName("buttonBox")
+        self.verticalLayout.addWidget(self.buttonBox)
+
+        self.retranslateUi(AnalysisDialog)
+        self.buttonBox.accepted.connect(AnalysisDialog.accept) # type: ignore
+        self.buttonBox.rejected.connect(AnalysisDialog.reject) # type: ignore
+        QtCore.QMetaObject.connectSlotsByName(AnalysisDialog)
+
+    def retranslateUi(self, AnalysisDialog):
+        _translate = QtCore.QCoreApplication.translate
+        AnalysisDialog.setWindowTitle(_translate("AnalysisDialog", "Analysis options"))
+        self.label_2.setText(_translate("AnalysisDialog", "Clustering K"))
+        self.label_10.setText(_translate("AnalysisDialog", "to"))
+        self.label.setText(_translate("AnalysisDialog", "Clustering restarts"))
+        self.label_3.setText(_translate("AnalysisDialog", "Nuclei expansion"))
+        self.label_4.setText(_translate("AnalysisDialog", "px"))
+        self.label_5.setText(_translate("AnalysisDialog", "Nuclei min area"))
+        self.label_6.setText(_translate("AnalysisDialog", "px"))

exhale_lung-1.3.0/exhale/analysisworker.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Mar 27 00:34:39 2026
+
+@author: carl
+"""
+
+import importlib
+from .elementsettings import ElementSettings
+from silx.gui import qt
+import contextlib
+
+
+class AnalysisWorker(qt.QObject):
+    progress = qt.Signal(str)
+    finished = qt.Signal(object)   # XRFSample
+    failed = qt.Signal(str)
+
+    def __init__(self, nuclei_es: ElementSettings, tissue_es: ElementSettings,
+                 element_settings: list, **process_args):
+        super().__init__()
+        print("AW init", self)
+        self.nuclei_es = nuclei_es
+        self.tissue_es = tissue_es
+        self.element_settings = element_settings
+        self.process_args = process_args
+        self._abort = False
+
+    @qt.Slot()
+    def run(self):
+        print("AW run", self)
+        try:
+            sample = self.xrf_analysis()
+        except InterruptedError:
+            self.failed.emit("")
+        except Exception:
+            import traceback
+            self.failed.emit(traceback.format_exc())
+        else:
+            self.finished.emit(sample)
+
+    @qt.Slot()
+    def abort(self):
+        print("AW abort", self)
+        self._abort = True
+
+    # def init_libs(self):
+    #     "Defers loading of TF, stardist and such"
+    #     # Uncomment in case we need to load from . instead of a specified path
+    #     # _cwd = os.getcwd()
+    #     # import exhale.resources
+    #     # os.chdir(next(iter(exhale.resources.__path__)))
+    #     from .xrf_refcopy import xrf_utils
+    #     xrf_utils.set_model_basedir(
+    #         importlib.resources.files("exhale").joinpath("resources"))
+    #     # os.chdir(_cwd)
+    #     # assert xrf_utils.model
+
+    def xrf_analysis(self):
+        # init_libs()
+
+        # self._abort = False
+        def progress_or_abort(msg):
+            if self._abort:
+                raise InterruptedError("Aborted")
+            self.progress.emit(msg)
+
+        # Try to intercept logging
+        import logging
+        class LogHandler(logging.Handler):
+            "Minimal logging handler"
+            def __init__(self):
+                logging.Handler.__init__(self, logging.DEBUG)
+                self.setFormatter(logging.Formatter(
+                    "[%(name)s] %(levelname)s: %(message)s"))
+            def emit(self, record):
+                try:
+                    msg = self.format(record)
+                except Exception:
+                    msg = record.getMessage()
+                progress_or_abort(msg)
+        tfLogHandler = LogHandler()
+        tf_log = logging.getLogger("tensorflow")
+        tf_log.setLevel(logging.DEBUG)
+        tf_log.addHandler(tfLogHandler)
+
+        class EmitStream():
+            "Stream that collects entire lines and emits them as progress"
+            def __init__(self):
+                self._s = []
+            def write(self, text):
+                self._s.append(text)
+                if "\n" in text:
+                    self.flush()
+            def flush(self):
+                s = "".join(self._s)
+                for t in s.split("\n"):
+                    if t:
+                        progress_or_abort(t)
+                self._s = []
+            def close(self):
+                ...
+        estream = EmitStream()
+
+        # Late loading of TF and stardist
+        with (contextlib.redirect_stdout(estream),
+            contextlib.redirect_stderr(estream)):
+            from .xrf_refcopy import xrf_utils
+            xrf_utils.set_model_basedir(
+                importlib.resources.files("exhale").joinpath("resources/models"))
+            from .xrf_refcopy.xrf_sample_class import XRFSample
+            from .xrf_refcopy.xrf_other_channel import NucleiChannel, TissueChannel
+
+        sample = XRFSample("Default_sample")
+        sample.nuclei = NucleiChannel(self.nuclei_es.data)
+        sample.tissue = TissueChannel(self.tissue_es.data)
+        for es in self.element_settings:
+            sample.add_element(es.name, es.data)
+
+        progress_or_abort("Preparing to process")
+        sample.process(callback=progress_or_abort, **self.process_args)
+        progress_or_abort("Processed; combining")
+        sample.combine(callback=progress_or_abort)
+        progress_or_abort("Analysis complete")
+        return sample
+

exhale_lung-1.3.0/exhale/cluster_analysis/__init__.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Sun Oct 12 21:26:36 2025
+
+@author: carl
+"""

exhale_lung-1.3.0/exhale/cluster_analysis/xrf_clustering.py

@@ -0,0 +1,169 @@
+from skimage import measure
+from sklearn.cluster import KMeans
+import numpy as np
+import pandas as pd
+
+# import dask.array as da
+# from dask.diagnostics import ProgressBar
+# import dask.dataframe as dd
+# import tensorflow as tf
+
+from sklearn.metrics import silhouette_score
+# from sklearn.cluster import KMeans
+from collections import Counter
+import dask
+from dask import delayed
+
+from . import xrf_general_functions as xgf
+
+@delayed
+def run_clustering(X, min_k=3, max_k=5, n_init=1):
+    best_k, best_score = None, -1
+    for k in range(min_k, max_k+1):
+        labels = KMeans(n_clusters=k, init='k-means++', max_iter=100, n_init=n_init).fit_predict(X)
+        score = silhouette_score(X, labels)
+        if score > best_score:
+            best_k, best_score = k, score
+    return best_k
+
+def measure_number_cluster_legacy(image, num_runs = 100):
+    # Assuming element_img is defined somewhere in your code
+
+    # Number of times to run the experiment
+
+
+    # Create a list of delayed tasks
+    tasks = [run_clustering(image) for _ in range(num_runs)]
+
+    # Compute the results in parallel
+    best_clusters_list = dask.compute(*tasks)
+
+    # Determine the most frequent number of clusters
+    most_frequent_clusters = Counter(best_clusters_list).most_common(1)[0][0]
+    #print("The most frequent best number of clusters is %i" % most_frequent_clusters)
+    return most_frequent_clusters
+
+def measure_number_cluster(X, min_k=3, max_k=5, n_init=100):
+    """Find best number of clusters in [min_k, max_k] using silhouette score."""
+    best_score, best_k = -1, min_k
+    for n_clusters in range(min_k, max_k + 1):
+        model = KMeans(n_clusters=n_clusters, init='k-means++', max_iter=100, n_init=n_init)
+        labels = model.fit_predict(X)
+        score = silhouette_score(X, labels)
+        if score > best_score:
+            best_score, best_k = score, n_clusters
+    return best_k
+
+def run_kmeans(img, num_clusters):
+    """Run KMeans clustering on the flattened image."""
+    kmeans = KMeans(n_clusters=num_clusters, init="k-means++")
+    flat_img = img.reshape(-1, 1)
+    kmeans.fit(flat_img)
+    return kmeans.labels_.reshape(img.shape)
+
+def extract_cluster_positions(labels, max_cluster_size=10000):
+    """Extract pixel positions for clusters below size threshold."""
+    cluster_positions = {}
+    cluster_sizes = np.bincount(labels.ravel())
+
+    for label, size in enumerate(cluster_sizes):
+        if size <= max_cluster_size:
+            coords = np.column_stack(np.where(labels == label))
+            cluster_positions[label] = coords
+
+    return cluster_positions
+
+def build_mask(img_shape, cluster_positions):
+    """Build boolean mask of all cluster positions."""
+    if not cluster_positions:
+        return np.zeros(img_shape, dtype=bool)
+
+    all_points = np.vstack(list(cluster_positions.values()))
+    mask = np.zeros(img_shape, dtype=bool)
+    mask[tuple(all_points.T)] = True
+    return mask
+
+def compute_cluster_properties(segmented_img, raw_img, min_area=1):
+    """Compute cluster properties and filter by area."""
+    labels = measure.label(segmented_img, connectivity=2)
+    props = measure.regionprops_table(
+        labels,
+        raw_img,
+        properties=["label", "area", "mean_intensity", "centroid"]
+    )
+    df = pd.DataFrame(props)
+    filtered_df = df[df["area"] > min_area]
+    return labels, filtered_df
+
+def measure_clusters_properties(img, num_clusters, raw_img, max_cluster_size=10000):
+    """Main pipeline: KMeans clustering + property extraction + filtering."""
+    # Step 1: Run clustering
+    k_labels = run_kmeans(img, num_clusters)
+
+    # Step 2: Extract cluster positions
+    cluster_positions = extract_cluster_positions(k_labels, max_cluster_size=max_cluster_size)
+
+    # Step 3: Build mask and segmented image
+    mask = build_mask(img.shape, cluster_positions)
+    segmented_img = xgf.build_segmented_image(img.shape, mask)
+
+    # Step 4: Compute cluster properties
+    labels, filtered_df = compute_cluster_properties(segmented_img, raw_img)
+
+    # Step 5: Filter image by properties
+    filtered_image = xgf.draw_filtered_img(labels, filtered_df)
+
+    return filtered_image, filtered_df
+
+
+#def measure_clusters_properties_v2(img, num_clusters, raw_img):
+    # Apply K-Means clustering
+    kmeans = KMeans(n_clusters=num_clusters, init='k-means++')
+    kmeans.fit(img.reshape(-1, 1))
+    # Extract cluster positions and calculate intensity and size
+    cluster_positions = {}
+
+    # Define a maximum size threshold for clusters
+    max_cluster_size = 10000  # Adjust this threshold as needed
+    # Get cluster labels
+    k_labels = kmeans.labels_
+    # cluster_sizes = np.bincount(k_labels)
+    for label in set(k_labels):
+        cluster_indices = np.where(k_labels == label)[0]
+        cluster_size = len(cluster_indices)
+
+        if cluster_size <= max_cluster_size:
+            # Collect cluster points
+            cluster_coords = np.unravel_index(cluster_indices, img.shape)
+            cluster_positions[label] = np.column_stack(cluster_coords)
+
+
+    # Prepare data for Napari
+    points_list = []
+    for cluster_id, positions in cluster_positions.items():
+        points_list.append(positions)
+
+    # If there are points to display, concatenate them into a single array
+    if points_list:
+        all_points = np.vstack(points_list)
+    else:
+        all_points = np.empty((0, 2))
+
+    # Create a mask for the segmented points
+    mask = np.zeros_like(img, dtype=bool)
+    for point in all_points:
+        mask[tuple(point)] = True
+
+    # Overlay the mask on the original image
+    segmented_img = np.zeros_like(img) #element_img.copy()
+    segmented_img[mask] = 1 #element_img[mask]#.max()  # Highlight segmented pixels
+
+    k_space_labels = measure.label(segmented_img, connectivity=2)
+    k_props = measure.regionprops_table(k_space_labels, raw_img, properties=['label', 'area', 'mean_intensity', 'centroid'])
+    k_df = pd.DataFrame(k_props)
+    filtered_k_df = k_df[(k_df['area']>1) ] #& (k_df['mean_intensity']>(np.exp(element_img)+c).mean())
+    mask = np.isin(k_space_labels, filtered_k_df)
+    filtered_image = np.zeros_like(k_space_labels)
+    filtered_image[mask] = k_space_labels[mask]
+
+    return filtered_image, filtered_k_df

exhale_lung-1.3.0/exhale/cluster_analysis/xrf_general_functions.py

@@ -0,0 +1,65 @@
+# from stardist.models import StarDist2D
+from csbdeep.utils import normalize
+# import tensorflow as tf
+
+# import os
+# from skimage import measure, io
+from skimage.segmentation import expand_labels
+import numpy as np
+import pandas as pd
+
+# os.environ["CUDA_VISIBLE_DEVICES"] = "0"
+# print("Num GPUs Available: ", len(tf.config.list_physical_devices('GPU')))
+# model = StarDist2D(None, '2D_versatile_fluo_copy', basedir='.')
+
+def log_img(img):
+    # Logarithmic transformation inspired by Fiji's "log" function
+    # Scale factor ensures result is normalized in [0,255]
+    c = 255 / np.log1p(img.max())
+    log_image = c * np.log1p(img.astype(np.float32))
+    # Subtract mean, clip negatives to zero, and cast back to original dtype
+    element_img = np.clip(log_image - log_image.mean(), 0, None).astype(img.dtype)
+    return element_img
+
+def draw_filtered_img(labels, df):
+    # Create a boolean mask where label IDs are in the filtered dataframe
+    mask = np.isin(labels, df['label'])
+    # Initialize empty mask with same shape as labels
+    filtered_image = np.zeros_like(labels)
+    filtered_image[mask] = labels[mask]
+    return filtered_image
+
+def build_segmented_image(img_shape, mask):
+    """Create binary image of segmented clusters."""
+    segmented_img = np.zeros(img_shape, dtype=np.uint8)
+    segmented_img[mask] = 1
+    return segmented_img
+
+def segment_nuclei(img_nuclei, model):
+    # Run deep learning segmentation model on nuclei channel
+    labels, _ = model.predict_instances(normalize(img_nuclei))
+    return labels
+
+def create_membrane_nuclei(labels_nuclei, expansion_size = 15, return_expanded = True):
+    # Expand nuclei labels by a fixed distance
+    expanded_labels = expand_labels(labels_nuclei, distance=expansion_size)
+    membrane_labels = expanded_labels - labels_nuclei
+    if return_expanded:
+        return expanded_labels, membrane_labels
+    else:
+        return membrane_labels
+
+def flatten_df(df, location):
+    # Flatten per-cell lists of cluster sizes and intensities into long format
+    flat_cluster_sizes = [item for sublist in df['cluster_sizes'] for item in sublist]
+    flat_cluster_intensities = [item for sublist in df['cluster_intensities'] for item in sublist]
+    elements = [df['element'][i] for i in range(len(df)) for _ in df['cluster_sizes'][i]]
+
+    # Construct normalized (flattened) dataframe
+    df_flat = pd.DataFrame({
+        'element': elements,
+        'cluster_size': flat_cluster_sizes,
+        'cluster_intensity': flat_cluster_intensities,
+        'location': location
+    })
+    return df_flat