napari-musa 1.0.0__py3-none-any.whl

napari_musa/Widgets_UMAP.py

@@ -0,0 +1,463 @@
+""" """
+
+import sys
+from os.path import dirname
+
+sys.path.append(dirname(dirname(__file__)))
+import napari
+import numpy as np
+import pyqtgraph as pg
+from magicgui.widgets import (
+    CheckBox,
+    ComboBox,
+    Container,
+    FloatSpinBox,
+    PushButton,
+    SpinBox,
+)
+from matplotlib.backends.backend_qt5agg import (
+    FigureCanvasQTAgg as FigureCanvas,
+)
+from matplotlib.backends.backend_qt5agg import (
+    NavigationToolbar2QT as NavigationToolbar,
+)
+from matplotlib.figure import Figure
+from napari.utils.notifications import show_info, show_warning
+from qtpy.QtWidgets import (
+    QGroupBox,
+    QHBoxLayout,
+    QScrollArea,
+    QVBoxLayout,
+    QWidget,
+)
+
+from napari_musa.modules.functions import (
+    RGB_to_hex,
+    UMAP_analysis,
+    reduce_spatial_dimension_dwt_inverse,
+)
+
+
+class UMAP(QWidget):
+    """ """
+
+    def __init__(self, viewer: napari.Viewer, data, plot):
+        """ """
+        super().__init__()
+        self.viewer = viewer
+        self.data = data
+        self.plot = plot
+        # Configure the scroll area
+        scroll = QScrollArea()
+        scroll.setWidgetResizable(True)
+        content_widget = QWidget()  # Container widget
+        content_layout = QVBoxLayout(
+            content_widget
+        )  # Vertical layout: organize widgets from top to bottom
+        # Configure UI
+        self.createUI(
+            content_layout
+        )  # The function to create the UI that fills the content_layout
+        # Configure principal layout
+        scroll.setWidget(
+            content_widget
+        )  # content_widget is a content of scroll area
+        main_layout = QVBoxLayout(self)
+        main_layout.addWidget(scroll)
+        self.setLayout(main_layout)
+
+    def createUI(self, layout):
+        """Create the components for the UI"""
+        layout.addWidget(self.create_umap_controls_box())
+        layout.addWidget(self.creare_scatterplot_box())
+        layout.addWidget(self.creare_plot_box())
+        layout.addWidget(self.create_inverse_reduction_box())
+
+        # %% Creation of UI boxes
+
+    def create_umap_controls_box(self):
+        """ """
+        controls_box = QGroupBox("UMAP Parameters")
+        # rgb_box.setFixedHeight(200)
+        controls_layout = QVBoxLayout()
+        controls_layout.addSpacing(10)
+        # Elements
+        row1 = QHBoxLayout()
+        self.reduced_dataset = CheckBox(text="Reduced dataset")
+        self.masked_dataset = CheckBox(text="Masked dataset")
+        self.modes_combobox = ComboBox(
+            choices=self.data.modes, label="Select the imaging mode"
+        )
+        row1.addWidget(self.reduced_dataset.native)
+        row1.addWidget(self.modes_combobox.native)
+        controls_layout.addLayout(row1)
+
+        row2 = QHBoxLayout()
+        row2.addWidget(self.masked_dataset.native)
+        controls_layout.addLayout(row2)
+
+        self.downsampling_spinbox = SpinBox(
+            min=1, max=6, value=1, step=1, name="Downsampling"
+        )
+        self.metric_dropdown = ComboBox(
+            choices=[
+                "cosine",
+                "euclidean",
+                "correlation",
+                "mahalanobis",
+                "seuclidean ",
+                "braycurtis",
+            ],
+            label="Select the metric",
+        )
+        self.n_neighbors_spinbox = SpinBox(
+            min=5, max=500, value=20, step=5, name="N Neighbours"
+        )
+        self.min_dist_spinbox = FloatSpinBox(
+            min=0.0, max=1.0, value=0.0, step=0.1, name="Min dist"
+        )
+        self.spread_spinbox = FloatSpinBox(
+            min=1.0, max=3.0, value=1.0, step=0.1, name="Spread"
+        )
+        self.init_dropdown = ComboBox(
+            choices=["spectral", "pca", "tswspectral"], label="Init"
+        )
+        self.densmap = CheckBox(text="Densmap")
+        controls_layout.addWidget(
+            Container(
+                widgets=[
+                    self.downsampling_spinbox,
+                    self.metric_dropdown,
+                    self.n_neighbors_spinbox,
+                    self.min_dist_spinbox,
+                    self.spread_spinbox,
+                    self.init_dropdown,
+                    self.densmap,
+                ]
+            ).native
+        )
+
+        run_btn = PushButton(text="Run UMAP")
+        run_btn.clicked.connect(self.run_umap)
+        controls_layout.addWidget(run_btn.native)
+
+        UMAP_loyout_perform = QHBoxLayout()
+        self.UMAP_colorRGB = CheckBox(text="Scatterplot with True RGB")
+        show_btn = PushButton(text="Show UMAP scatterplot")
+        show_btn.clicked.connect(self.show_umap_scatter)
+        UMAP_loyout_perform.addWidget(
+            Container(
+                widgets=[self.UMAP_colorRGB, show_btn], layout="horizontal"
+            ).native
+        )
+        controls_layout.addLayout(UMAP_loyout_perform)
+        controls_box.setLayout(controls_layout)
+        return controls_box
+
+    def creare_scatterplot_box(self):
+        """ """
+        scatterplot_box = QGroupBox("UMAP Scatterplot")
+        layout = QVBoxLayout()
+        layout.addSpacing(10)
+        self.umap_plot = pg.PlotWidget()
+        self.plot.setup_scatterplot(self.umap_plot)
+        # Add control buttons for scatter plot interaction
+        btn_layout = QHBoxLayout()
+        for icon, func in [
+            ("fa5s.home", lambda: self.umap_plot.getViewBox().autoRange()),
+            (
+                "fa5s.draw-polygon",
+                lambda: self.plot.polygon_selection(self.umap_plot),
+            ),
+            ("ri.add-box-fill", self.handle_selection),
+            (
+                "mdi6.image-edit",
+                lambda: self.plot.save_image_button(self.umap_plot),
+            ),
+        ]:
+            btn = self.plot.create_button(icon)
+            btn.clicked.connect(func)
+            btn_layout.addWidget(btn)
+        self.point_size = SpinBox(
+            min=1, max=100, value=1, step=1, name="Point size"
+        )
+        show_areas_on_scatterplot_btn = PushButton(
+            text="Show areas of Label Layer on scatteplot"
+        )
+        show_areas_on_scatterplot_btn.clicked.connect(
+            self.show_areas_on_scatterplot_btn_f
+        )
+        btn_layout.addSpacing(30)
+        btn_layout.addWidget(Container(widgets=[self.point_size]).native)
+        layout.addLayout(btn_layout)
+        layout.addWidget(self.umap_plot)
+        layout.addWidget(show_areas_on_scatterplot_btn.native)
+        scatterplot_box.setLayout(layout)
+        return scatterplot_box
+
+    def creare_plot_box(self):
+        """ """
+        meanplot_box = QGroupBox("Mean plot")
+        layout = QVBoxLayout()
+        layout.addSpacing(20)
+        layout = QVBoxLayout()
+        self.mean_plot = FigureCanvas(Figure(figsize=(5, 3)))
+        self.mean_plot.setMinimumSize(300, 450)
+        self.mean_plot_toolbar = NavigationToolbar(self.mean_plot, self)
+        self.plot.customize_toolbar(self.mean_plot_toolbar)
+        self.plot.setup_plot(self.mean_plot)
+
+        mean_spec_btn = PushButton(text="Mean Spectrum")
+        self.std_checkbox = CheckBox(text="Plot Std Dev")
+        self.norm_checkbox = CheckBox(text="Normalize")
+        self.derivative_checkbox = CheckBox(text="Derivative")
+
+        mean_spec_btn.clicked.connect(
+            lambda: self.plot.show_plot(
+                self.mean_plot,
+                mode=self.modes_combobox.value,
+                std_flag=self.std_checkbox.value,
+                norm_flag=self.norm_checkbox.value,
+                reduced_dataset_flag=self.reduced_dataset.value,
+                derivative_flag=self.derivative_checkbox.value,
+            )
+        )
+
+        controls = [
+            self.std_checkbox,
+            self.norm_checkbox,
+            self.derivative_checkbox,
+            mean_spec_btn,
+        ]
+        layout.addWidget(Container(widgets=controls).native)
+        layout.addWidget(self.mean_plot)
+        layout.addWidget(self.mean_plot_toolbar)
+
+        # Export button
+        export_btn = PushButton(text="Export spectra")
+        export_btn.clicked.connect(
+            lambda: (
+                self.plot.show_plot(
+                    self.mean_plot,
+                    mode=self.modes_combobox.value,
+                    std_flag=self.std_checkbox.value,
+                    norm_flag=self.norm_checkbox.value,
+                    reduced_dataset_flag=self.reduced_dataset.value,
+                    export_txt_flag=True,
+                )
+            )
+        )
+        layout.addWidget(Container(widgets=[export_btn]).native)
+        meanplot_box.setLayout(layout)
+        return meanplot_box
+
+    def create_inverse_reduction_box(self):
+        """ """
+        inverse_reduction_box = QGroupBox("Inverse Dimensionality Reduction")
+        # rgb_box.setFixedHeight(200)
+        inverse_reduction_layout = QVBoxLayout()
+        inverse_reduction_layout.addSpacing(10)
+        # Elements
+        inverse_reduction_btn = PushButton(text="Perform inverse reduction")
+        inverse_reduction_btn.clicked.connect(self.inverse_reduction_btn_f)
+        inverse_reduction_layout.addWidget(inverse_reduction_btn.native)
+
+        inverse_reduction_box.setLayout(inverse_reduction_layout)
+        return inverse_reduction_box
+
+    def run_umap(self):
+        """Perform UMAP"""
+        mode = self.modes_combobox.value
+        if self.masked_dataset.value:
+            dataset = self.data.hypercubes_masked[mode]
+            data_reshaped = dataset.reshape(
+                dataset.shape[0] * dataset.shape[1], -1
+            )
+            self.points = np.array(
+                np.where(~np.isnan(np.mean(data_reshaped, axis=1)))
+            ).flatten()
+        elif self.reduced_dataset.value:
+            dataset = self.data.hypercubes_red[mode]
+            self.points = []
+        else:
+            dataset = self.data.hypercubes[mode]
+            self.points = []
+
+        self.data.umap_maps[mode] = UMAP_analysis(
+            dataset,
+            downsampling=self.downsampling_spinbox.value,
+            points=self.points,
+            metric=self.metric_dropdown.value,
+            n_neighbors=self.n_neighbors_spinbox.value,
+            min_dist=self.min_dist_spinbox.value,
+            spread=self.spread_spinbox.value,
+            init=self.init_dropdown.value,
+            densmap=self.densmap.value,
+            random_state=42,
+        )
+        show_info("UMAP analysis completed!")
+
+    def show_umap_scatter(self):
+        """Plot UMAP scatter plot"""
+        mode = self.modes_combobox.value
+        self.umap_data = self.data.umap_maps[mode]
+        if self.UMAP_colorRGB.value:
+            if self.reduced_dataset.value:
+                colors = np.array(RGB_to_hex(self.data.rgb_red[mode])).reshape(
+                    -1
+                )
+            elif self.masked_dataset.value:
+                colors = np.array(
+                    RGB_to_hex(self.data.rgb_masked[mode])
+                ).reshape(-1)
+            else:
+                colors = np.array(RGB_to_hex(self.data.rgb[mode])).reshape(-1)
+        else:
+            colors = pg.mkBrush("#262930")
+
+        print("Colors: \n", colors)
+        self.plot.show_scatterplot(
+            self.umap_plot,
+            self.umap_data,
+            colors,
+            self.points,
+            self.point_size.value,
+        )
+
+    def handle_selection(self):
+        """Handle polygon selection and create label layer"""
+        mode = self.modes_combobox.value
+        if self.reduced_dataset.value and not self.masked_dataset.value:
+            dataset = self.data.hypercubes_red[mode]
+            self.points = []
+        elif self.masked_dataset.value or (
+            self.reduced_dataset.value and self.masked_dataset.value
+        ):
+            dataset = self.data.hypercubes_masked[mode]
+            data_reshaped = dataset.reshape(
+                dataset.shape[0] * dataset.shape[1], -1
+            )
+            self.points = np.array(
+                np.where(~np.isnan(np.mean(data_reshaped, axis=1)))
+            ).flatten()
+        else:
+            dataset = self.data.hypercubes[mode]
+            self.points = []
+        self.plot.show_selected_points(
+            self.umap_data,
+            dataset,
+            mode,
+            self.points,
+        )
+
+    def show_areas_on_scatterplot_btn_f(self):
+        mode = self.modes_combobox.value
+        selected_layer = self.viewer.layers.selection.active
+        # Check if the selected layer is a label layer
+        if not isinstance(selected_layer, napari.layers.Labels):
+            show_warning(
+                "⚠️ The selected layer is not a label layer. Please, select a label layer."
+            )
+            return
+        labels_data = selected_layer.data
+        if labels_data is None or np.all(
+            labels_data == 0
+        ):  # check if all elements are 0
+            show_warning("⚠️ The selected label layer is empty")
+            return
+        # num_classes = int(labels_data.max())
+        colormap = np.array(selected_layer.colormap.colors)
+        print(colormap)
+        print(colormap.shape)
+        # colormap[0] = [0, 0, 0, 0.5]
+        rgb_image = colormap[labels_data]  # fancy indexing
+        if self.reduced_dataset.value:
+            dataset = self.data.hypercubes_red[mode]
+            rgb_image = rgb_image[: dataset.shape[0], : dataset.shape[1], :]
+        print(rgb_image)
+        print(rgb_image.shape)
+        colors = RGB_to_hex(rgb_image)
+
+        self.plot.show_scatterplot(
+            self.umap_plot,
+            self.umap_data,
+            colors.reshape(-1),
+            self.points,
+            self.point_size.value,
+        )
+
+    def inverse_reduction_btn_f(self):
+        mode = self.modes_combobox.value
+        selected_layer = self.viewer.layers.selection.active
+
+        if isinstance(selected_layer, napari.layers.Labels):
+            label_data = selected_layer.data
+            reduced_data = self.data.hypercubes_spatial_red[mode]
+            print(label_data.shape)
+            label_data = label_data[
+                : reduced_data.shape[0], : reduced_data.shape[1]
+            ]
+            num_classes = int(label_data.max())
+            # colormap = np.array(selected_layer.colormap.colors)
+            reduced_data_masked = np.zeros(
+                (label_data.shape[0], label_data.shape[1], num_classes)
+            )
+            print(self.data.hypercubes_spatial_red_params[mode])
+            print(self.data.hypercubes_spatial_red_params[mode][0])
+            LH = reduced_data_masked
+            HL = reduced_data_masked
+            HH = reduced_data_masked
+            for idx in range(num_classes):
+                points = np.where(label_data == idx + 1, 1, 0).astype(float)
+                print("Points shape:", points.shape)
+                reduced_data_masked[:, :, idx] = (
+                    np.mean(reduced_data, axis=2) * points
+                )
+                LH[:, :, idx] = (
+                    np.mean(
+                        self.data.hypercubes_spatial_red_params[mode][0],
+                        axis=2,
+                    )
+                    * points
+                )
+                HL[:, :, idx] = (
+                    np.mean(
+                        self.data.hypercubes_spatial_red_params[mode][1],
+                        axis=2,
+                    )
+                    * points
+                )
+                HH[:, :, idx] = (
+                    np.mean(
+                        self.data.hypercubes_spatial_red_params[mode][2],
+                        axis=2,
+                    )
+                    * points
+                )
+            reconstructed_data_masked = reduce_spatial_dimension_dwt_inverse(
+                reduced_data_masked,
+                (LH, HL, HH, self.data.hypercubes_spatial_red_params[mode][3]),
+            )
+            masks = reconstructed_data_masked != 0  # boolean
+            H, W, K = masks.shape
+            labels_reconstructed = np.zeros((H, W), dtype=np.int32)
+            for k in range(
+                K
+            ):  # first mask wins on the others, but with UMAP i should not have overlapping areas
+                sel = masks[:, :, k] & (labels_reconstructed == 0)
+                labels_reconstructed[sel] = k + 1
+            lenx, leny, lenwl = self.data.hypercubes[mode].shape
+            labels_reconstructed = labels_reconstructed[:lenx, :leny]
+            # K = colormap.shape[0] - 1
+            # color_dict = {i: colormap[i, :3] for i in range(1, K+1)}
+            self.viewer.add_labels(
+                labels_reconstructed,
+                name=str(mode) + " - Inverse Reduced Selection",
+            )
+
+        else:
+            show_warning(
+                "⚠️ The selected layer is not a label layer. Please, select an image layer."
+            )
+            return
+        return

napari_musa/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '1.0.0'
+__version_tuple__ = version_tuple = (1, 0, 0)
+
+__commit_id__ = commit_id = None

napari_musa/main.py

@@ -0,0 +1,150 @@
+""" """
+
+import napari
+import napari as np
+from qtpy.QtCore import QTimer
+
+from napari_musa.modules.data import Data
+from napari_musa.modules.plot import Plot
+from napari_musa.Widget_DataManager import DataManager
+from napari_musa.Widgets_DataVisualization import DataVisualization
+from napari_musa.Widgets_EndmembersExtraction import EndmembersExtraction
+from napari_musa.Widgets_Fusion import Fusion
+from napari_musa.Widgets_NMF import NMF
+from napari_musa.Widgets_PCA import PCA
+from napari_musa.Widgets_UMAP import UMAP
+
+
+def setup_connections(self):
+    """ """
+    self.viewer.text_overlay.visible = True
+
+    def on_step_change(event=None):
+        layer = self.viewer.layers.selection.active
+        if layer and isinstance(layer, napari.layers.Image):
+            name = layer.name
+            if "NNLS" in name or "SAM" in name:
+                self.endmextr_widget.update_number_H()
+            elif "NMF" in name:
+                self.nmf_widget.update_number_H()
+            elif "PCA" in name:
+                self.pca_widget.update_number_H()
+            else:
+                self.datamanager_widget.update_wl()
+
+    # collega la funzione wrapper
+    self.viewer.dims.events.current_step.connect(on_step_change)
+
+    # resto invariato
+    self.viewer.layers.selection.events.active.connect(
+        self.datamanager_widget.layer_auto_selection
+    )
+
+
+def on_new_layer(self, event):
+    layer = event.value
+    if (
+        isinstance(layer, napari.layers.Labels) and layer.data.ndim == 3
+    ):  # (C, Y, X)
+
+        def replace():
+            if layer in self.viewer.layers:  # solo se esiste ancora
+                new_labels = np.zeros(layer.data.shape[1:], dtype=np.int32)
+                name = layer.name
+                self.viewer.layers.remove(layer)
+                self.viewer.add_labels(new_labels, name=name)
+
+        QTimer.singleShot(0, replace)
+
+
+def update_modes_comboboxes(self):
+    for widget in [
+        self.datamanager_widget,
+        self.umap_widget,
+        self.fusion_widget,
+        self.endmextr_widget,
+        self.pca_widget,
+        self.nmf_widget,
+    ]:
+        for attr_name in dir(widget):
+            if attr_name.startswith("modes_combobox"):
+                if widget == self.fusion_widget:
+                    widget.modes_combobox_1.choices = self.data.modes
+                    widget.modes_combobox_2.choices = self.data.modes
+                    widget.modes_combobox_3.choices = self.data.modes
+                else:
+                    current_value = widget.modes_combobox.value
+                    widget.modes_combobox.choices = self.data.modes
+                if current_value not in self.data.modes:
+                    widget.modes_combobox.value = current_value
+
+
+def run_napari_app():
+    """Add widgets to the viewer"""
+    try:
+        viewer = napari.current_viewer()
+    except AttributeError:
+        viewer = napari.Viewer()
+
+    # WIDGETS
+    data = Data()
+    plot_datavisualization = Plot(viewer=viewer, data=data)
+    datamanager_widget = DataManager(viewer, data)
+    datavisualization_widget = DataVisualization(
+        viewer, data, plot_datavisualization, datamanager_widget
+    )
+    fusion_widget = Fusion(viewer, data)
+
+    plot_umap = Plot(viewer=viewer, data=data)
+    umap_widget = UMAP(viewer, data, plot_umap)
+    nmf_widget = NMF(viewer, data, plot_umap)
+    endmextr_widget = EndmembersExtraction(viewer, data, plot_umap)
+    plot_pca = Plot(viewer=viewer, data=data)
+    pca_widget = PCA(viewer, data, plot_pca)
+
+    datamanager_widget.mode_added.connect(update_modes_comboboxes)
+
+    # Add widget as dock
+    datamanager_dock = viewer.window.add_dock_widget(
+        datamanager_widget, name="Data Manager", area="right"
+    )
+    datavisualization_dock = viewer.window.add_dock_widget(
+        datavisualization_widget, name="Data Visualization", area="right"
+    )
+    fusion_dock = viewer.window.add_dock_widget(
+        fusion_widget, name="Fusion", area="right"
+    )
+    umap_dock = viewer.window.add_dock_widget(
+        umap_widget, name="UMAP", area="right"
+    )
+    endmextr_dock = viewer.window.add_dock_widget(
+        endmextr_widget, name="Endmembers", area="right"
+    )
+    pca_dock = viewer.window.add_dock_widget(
+        pca_widget, name="PCA", area="right"
+    )
+    nmf_dock = viewer.window.add_dock_widget(
+        nmf_widget, name="NMF", area="right"
+    )
+
+    # Tabify the widgets
+    viewer.window._qt_window.tabifyDockWidget(
+        datamanager_dock, datavisualization_dock
+    )
+    viewer.window._qt_window.tabifyDockWidget(
+        datavisualization_dock, fusion_dock
+    )
+    viewer.window._qt_window.tabifyDockWidget(fusion_dock, umap_dock)
+    viewer.window._qt_window.tabifyDockWidget(umap_dock, pca_dock)
+    viewer.window._qt_window.tabifyDockWidget(pca_dock, endmextr_dock)
+    viewer.window._qt_window.tabifyDockWidget(endmextr_dock, nmf_dock)
+    # Text overlay in the viewer
+    viewer.text_overlay.visible = True
+
+    setup_connections()
+    viewer.layers.events.inserted.connect(on_new_layer)
+    viewer.layers.selection.events.active.connect(
+        datamanager_widget.on_layer_selected
+    )
+
+    return None  # Non serve restituire nulla

napari_musa/modules/data.py

@@ -0,0 +1,48 @@
+""" """
+
+import sys
+from os.path import dirname
+
+sys.path.append(dirname(dirname(__file__)))
+
+# print("here: ", dirname(dirname(__file__)))    #print for the directory folder
+
+
+class Data:
+    """ """
+
+    def __init__(self):
+        """ """
+        self.filepath = ""
+        self.hypercubes = {}
+        self.hypercubes_red = {}
+        self.hypercubes_spatial_red = {}  # For the spectra
+        self.hypercubes_spatial_red_params = {}
+        self.hypercubes_masked = {}
+        self.wls = {}
+        self.rgb = {}  # Dictionary needed for the fusion process
+        self.rgb_red = {}  # Dictionary needed for the fusion process
+        self.rgb_masked = {}
+        self.wls_red = {}
+        self.pca_maps = {}
+        self.nmf_maps = {}
+        self.nmf_basis = {}
+        self.svd_maps = {}
+        self.umap_maps = {}  # valutare se da togliere.
+        self.vertex_basis = {}
+        self.nnls_maps = {}
+        self.sam_maps = {}
+        self.modes = [
+            "Reflectance",
+            "PL",
+            "PL - 2",
+            "Raman",
+            "Fused",
+            "-",
+        ]  # fused: self.modes.append
+        self.mode = None  # valutare se da togliere con nuovo widget
+        self.wl_value = 0
+        self.fusion_modes = []
+
+
+# %% Other functions