ImageSeriesWidget fixes

nwbwidgets/image.py

@@ -1,94 +1,173 @@
-from pathlib import Path, PureWindowsPath
+from pathlib import Path
+from typing import Union
 
 import matplotlib.pyplot as plt
+import numpy as np
 import plotly.graph_objects as go
 import pynwb
-from ipywidgets import widgets, fixed, Layout
+from ipywidgets import widgets, Layout
 from pynwb.image import GrayscaleImage, ImageSeries, RGBImage
-from tifffile import imread, TiffFile
 
 from .base import fig2widget
-from .controllers import StartAndDurationController
+from .utils.cmaps import linear_transfer_function
+from .utils.imageseries import get_frame_count, get_frame
 from .utils.timeseries import (
     get_timeseries_maxt,
     get_timeseries_mint,
     timeseries_time_to_ind,
 )
 
+PathType = Union[str, Path]
+
 
 class ImageSeriesWidget(widgets.VBox):
     """Widget showing ImageSeries."""
 
     def __init__(
         self,
         imageseries: ImageSeries,
-        foreign_time_window_controller: StartAndDurationController = None,
-        **kwargs
+        foreign_time_slider: widgets.FloatSlider = None,
+        neurodata_vis_spec: dict = None,
     ):
         super().__init__()
         self.imageseries = imageseries
-        self.controls = {}
-        self.out_fig = None
+        self.figure = None
+        self.time_slider = foreign_time_slider
 
-        # Set controller
-        if foreign_time_window_controller is None:
-            tmin = get_timeseries_mint(imageseries)
-            if imageseries.external_file and imageseries.rate:
-                tif = TiffFile(imageseries.external_file[0])
-                tmax = imageseries.starting_time + len(tif.pages) / imageseries.rate
-            else:
-                tmax = get_timeseries_maxt(imageseries)
-            self.time_window_controller = StartAndDurationController(tmax, tmin)
+        if imageseries.external_file is not None:
+
+            # set time slider:
+            tmax = (
+                imageseries.starting_time
+                + get_frame_count(imageseries.external_file[0]) / imageseries.rate
+            )
+            if self.time_slider is None:
+                self.time_slider = widgets.FloatSlider(
+                    min=imageseries.starting_time,
+                    max=tmax,
+                    orientation="horizontal",
+                    description="time(s)",
+                )
+            external_file = imageseries.external_file[0]
+            self.file_selector = None
+            # set file selector:
+            if len(imageseries.external_file) > 1:
+                self.file_selector = widgets.Dropdown(options=imageseries.external_file)
+                external_file = self.file_selector.value
+
+                def update_time_slider(value):
+                    path_ext_file = value["new"]
+                    # Read first frame
+                    nonlocal external_file
+                    external_file = path_ext_file
+                    tmax = (
+                        imageseries.starting_time
+                        + get_frame_count(path_ext_file) / imageseries.rate
+                    )
+                    tmin = 0
+                    self.time_slider.max = tmax
+                    self.time_slider.min = tmin
+                    self._set_figure_external(tmin, external_file, tmin)
+
+                self.file_selector.observe(update_time_slider, names="value")
+
+            # set time slider callbacks:
+            def change_fig(change):
+                time = change["new"]
+                starting_time = change["owner"].min
+                self._set_figure_external(time, external_file, starting_time)
+
+            self.time_slider.observe(change_fig, names="value")
+            self._set_figure_external(
+                imageseries.starting_time, external_file, imageseries.starting_time
+            )
+            # set children:
+            self.children = self.get_children(self.file_selector)
         else:
-            self.time_window_controller = foreign_time_window_controller
-        self.set_controls(**kwargs)
+            if len(imageseries.data.shape) == 3:
+                self._set_figure_2d(0)
 
-        # Make widget figure
-        self.set_out_fig()
+                def time_slider_callback(change):
+                    frame_number = self.time_to_index(change["new"])
+                    self._set_figure_2d(frame_number)
 
-        self.children = [self.out_fig, self.time_window_controller]
+            elif len(imageseries.data.shape) == 4:
+                self._set_figure_3d(0)
 
-    def time_to_index(self, time):
-        if self.imageseries.external_file and self.imageseries.rate:
-            return int((time - self.imageseries.starting_time) * self.imageseries.rate)
-        else:
-            return timeseries_time_to_ind(self.imageseries, time)
+                def time_slider_callback(change):
+                    frame_number = self.time_to_index(change["new"])
+                    self._set_figure_3d(frame_number)
 
-    def set_controls(self, **kwargs):
-        self.controls.update(
-            timeseries=fixed(self.imageseries), time_window=self.time_window_controller
+            else:
+                raise NotImplementedError
+
+            # creat time window controller:
+            tmin = get_timeseries_mint(imageseries)
+            tmax = get_timeseries_maxt(imageseries)
+            if self.time_slider is None:
+                self.time_slider = widgets.FloatSlider(
+                    value=tmin,
+                    min=tmin,
+                    max=tmax,
+                    orientation="horizontal",
+                    description="time(s)",
+                )
+            self.time_slider.observe(time_slider_callback, names="value")
+            self.children = self.get_children()
+
+    def _set_figure_3d(self, frame_number):
+        import ipyvolume.pylab as p3
+
+        output = widgets.Output()
+        p3.figure()
+        p3.volshow(
+            self.imageseries.data[frame_number].transpose([1, 0, 2]),
+            tf=linear_transfer_function([0, 0, 0], max_opacity=0.3),
         )
-        self.controls.update({key: widgets.fixed(val) for key, val in kwargs.items()})
+        output.clear_output(wait=True)
+        self.figure = output
+        with output:
+            p3.show()
+
+    def _set_figure_2d(self, frame_number):
+        data = self.imageseries.data[frame_number].T
+        if self.figure is None:
+            self.figure = go.FigureWidget(data=dict(type="image", z=data))
+        else:
+            self._add_fig_trace(data, frame_number)
 
-    def get_frame(self, idx):
-        if self.imageseries.external_file is not None:
-            return imread(self.imageseries.external_file, key=idx)
+    def _set_figure_external(self, time, ext_file_path, starting_time):
+        frame_number = self.time_to_index(time, starting_time)
+        data = get_frame(ext_file_path, frame_number)
+        if self.figure is None:
+            self.figure = go.FigureWidget(data=dict(type="image", z=data))
         else:
-            return self.image_series.data[idx].T
+            self._add_fig_trace(data, frame_number)
 
-    def set_out_fig(self):
+    def _add_fig_trace(self, img_data: np.ndarray, index):
+        self.figure.data[0]["z"] = img_data
+        self.figure.layout.title = f"Frame no: {index}"
 
-        self.out_fig = go.FigureWidget(
-            data=go.Heatmap(
-                z=self.get_frame(0),
-                colorscale="gray",
-                showscale=False,
-            )
-        )
-        self.out_fig.update_layout(
-            xaxis=go.layout.XAxis(showticklabels=False, ticks=""),
-            yaxis=go.layout.YAxis(
-                showticklabels=False, ticks="", scaleanchor="x", scaleratio=1
-            ),
+    def time_to_index(self, time, starting_time=None):
+        starting_time = (
+            starting_time
+            if starting_time is not None
+            else self.imageseries.starting_time
         )
+        if self.imageseries.external_file and self.imageseries.rate:
+            return int((time - starting_time) * self.imageseries.rate)
+        else:
+            return timeseries_time_to_ind(self.imageseries, time)
 
-        def on_change(change):
-            # Read frame
-            frame_number = self.time_to_index(change["new"][0])
-            image = self.get_frame(frame_number)
-            self.out_fig.data[0].z = image
+    def get_children(self, *widgets):
+        set_widgets = [wid for wid in widgets if wid is not None]
+        return [self.figure, self.time_slider, *set_widgets]
 
-        self.controls["time_window"].observe(on_change)
+    def get_frame(self, idx):
+        if self.imageseries.external_file is not None:
+            return get_frame(self.imageseries.external_file[0])
+        else:
+            return self.imageseries.data[idx].T
 
 
 def show_image_series(image_series: ImageSeries, neurodata_vis_spec: dict):

nwbwidgets/ophys.py

@@ -3,7 +3,6 @@
 import ipywidgets as widgets
 import numpy as np
 import plotly.graph_objects as go
-import plotly.express as px
 from ndx_grayscalevolume import GrayscaleVolume
 from pynwb.base import NWBDataInterface
 from pynwb.ophys import (
@@ -14,89 +13,22 @@
     ImageSegmentation,
 )
 from skimage import measure
-from tifffile import imread, TiffFile
 
 from .base import df_to_hover_text
+from .controllers import ProgressBar
+from .image import ImageSeriesWidget
 from .timeseries import BaseGroupedTraceWidget
 from .utils.cmaps import linear_transfer_function
 from .utils.dynamictable import infer_categorical_columns
-from .controllers import ProgressBar
 
 color_wheel = ["red", "blue", "green", "black", "magenta", "yellow"]
 
 
-class TwoPhotonSeriesWidget(widgets.VBox):
+class TwoPhotonSeriesWidget(ImageSeriesWidget):
     """Widget showing Image stack recorded over time from 2-photon microscope."""
 
-    def __init__(self, indexed_timeseries: TwoPhotonSeries, neurodata_vis_spec: dict):
-        super().__init__()
-
-        def _add_fig_trace(img_fig: go.Figure, index):
-            if self.figure is None:
-                self.figure = go.FigureWidget(img_fig)
-            else:
-                self.figure.for_each_trace(lambda trace: trace.update(img_fig.data[0]))
-            self.figure.layout.title = f"Frame no: {index}"
-
-        if indexed_timeseries.data is None:
-            if indexed_timeseries.external_file is not None:
-                path_ext_file = indexed_timeseries.external_file[0]
-                # Get Frames dimensions
-                tif = TiffFile(path_ext_file)
-                n_samples = len(tif.pages)
-                page = tif.pages[0]
-                n_y, n_x = page.shape
-
-                def update_figure(index=0):
-                    # Read first frame
-                    img_fig = px.imshow(
-                        imread(path_ext_file, key=int(index)), binary_string=True
-                    )
-                    _add_fig_trace(img_fig, index)
-
-                slider = widgets.IntSlider(
-                    value=0, min=0, max=n_samples - 1, orientation="horizontal"
-                )
-        else:
-            if len(indexed_timeseries.data.shape) == 3:
-
-                def update_figure(index=0):
-                    img_fig = px.imshow(
-                        indexed_timeseries.data[index].T, binary_string=True
-                    )
-                    _add_fig_trace(img_fig, index)
-
-            elif len(indexed_timeseries.data.shape) == 4:
-                import ipyvolume.pylab as p3
-
-                output = widgets.Output()
-
-                def update_figure(index=0):
-                    p3.figure()
-                    p3.volshow(
-                        indexed_timeseries.data[index].transpose([1, 0, 2]),
-                        tf=linear_transfer_function([0, 0, 0], max_opacity=0.3),
-                    )
-                    output.clear_output(wait=True)
-                    self.figure = output
-                    with output:
-                        p3.show()
-
-            else:
-                raise NotImplementedError
-
-            slider = widgets.IntSlider(
-                value=0,
-                min=0,
-                max=indexed_timeseries.data.shape[0] - 1,
-                orientation="horizontal",
-            )
-
-        slider.observe(lambda change: update_figure(change.new), names="value")
-        self.figure = None
-        self.controls = dict(slider=slider)
-        update_figure()
-        self.children = [self.figure, slider]
+    def __init__(self, indexed_timeseries: TwoPhotonSeries, neurodata_vis_spec: dict = None):
+        super().__init__(indexed_timeseries,neurodata_vis_spec)
 
 
 def show_df_over_f(df_over_f: DfOverF, neurodata_vis_spec: dict):
@@ -223,13 +155,13 @@ def update_fig(self, color_by):
                     data.showlegend = False
 
     def show_plane_segmentation_2d(
-        self,
-        color_wheel: list = color_wheel,
-        color_by: str = None,
-        threshold: float = 0.01,
-        fig: go.Figure = None,
-        width: int = 600,
-        ref_image=None,
+            self,
+            color_wheel: list = color_wheel,
+            color_by: str = None,
+            threshold: float = 0.01,
+            fig: go.Figure = None,
+            width: int = 600,
+            ref_image=None,
     ):
         """
 
@@ -360,6 +292,6 @@ def show_grayscale_volume(vol: GrayscaleVolume, neurodata_vis_spec: dict):
 
 class RoiResponseSeriesWidget(BaseGroupedTraceWidget):
     def __init__(
-        self, roi_response_series: RoiResponseSeries, neurodata_vis_spec=None, **kwargs
+            self, roi_response_series: RoiResponseSeries, neurodata_vis_spec=None, **kwargs
     ):
         super().__init__(roi_response_series, "rois", **kwargs)