labdata 0.1.2__tar.gz → 0.1.4__tar.gz

{labdata-0.1.2 → labdata-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: labdata
-Version: 0.1.2
+Version: 0.1.4
 Summary: Package to manage data in experimental neuroscience labs
 Author-email: Joao Couto <jpcouto@gmail.com>
 Project-URL: Homepage, https://github.com/jcouto/labdata

{labdata-0.1.2 → labdata-0.1.4}/labdata/__init__.py

@@ -1,4 +1,4 @@
-VERSION = "0.1.2"
+VERSION = "0.1.4"
 
 from .utils import *
 from .copy import copy_to_upload_server

{labdata-0.1.2 → labdata-0.1.4}/labdata/compute/caiman.py

@@ -22,7 +22,7 @@ class CaimanCompute(Suite2pCompute):
         # default parameters
         self.parameters = dict(algorithm_name = 'caiman')
         # will only store these in CellSegmentationParams
-        self.parameter_keys = ['pw_rigid','p','gSig','gSig_filt','max_shift','gSiz','merge_thr','rf','stride','tsub',
+        self.parameter_keys = ['pw_rigid','p','gSig','gSig_filt','max_shifts','gSiz','merge_thr','rf','stride','tsub',
                                'ssub','nb','min_corr','min_pnr','ssub_B','ring_size_factor',
                                'min_SNR', 'rval_thr', 'use_cnn', 'detrendWin','quantileMin','denoise_dff']
         
@@ -50,7 +50,7 @@ class CaimanCompute(Suite2pCompute):
             parser.add_argument('-m','--pwrigid',
                                 action='store_true', default=False,
                                 help = "Piecewise-rigid registration")
-            parser.add_argument('--max-allowed-shift',
+            parser.add_argument('--max-allowed-shifts',
                                 action='store', default=[20,20], type = int, nargs = 2,
                                 help = "maximum allowed shift for motion correction")
             parser.add_argument('-p',
@@ -122,7 +122,6 @@ class CaimanCompute(Suite2pCompute):
                           max_shifts = args.max_allowed_shifts,
                           p = int(args.p),
                           gSig = [int(a) for a in args.gsig], 
-                          gSig_filt = [int(a) for a in args.gsig_filt], 
                           gSiz = [int(a) for a in 2*np.array(args.gsig) + 1],
                           merge_thr = float(args.merge_thr),      
                           rf = int(args.rf),                    
@@ -140,7 +139,10 @@ class CaimanCompute(Suite2pCompute):
                           detrendWin = int(args.detrend_win),
                           denoise_dff = bool(args.denoise_dff),
                           quantileMin = float(args.quantile_min),
-                          roi = args.roi)   
+                          roi = args.roi)
+            if not args.gsig_filt is None:
+                params['gSig_filt'] = [int(a) for a in args.gsig_filt], 
+
             self.parameters = params
         
     def _compute(self):
@@ -338,7 +340,7 @@ class CaimanCompute(Suite2pCompute):
                     os.unlink(f)
         else:
             print(f'[{self.name} job] Kept the temporary folder {temporary_folder}.')
-        CellSegmentationMetrics().populate(planekey, display_progress = True)
+        self.schema.CellSegmentationMetrics().populate(dkey, display_progress = True)
         
 def setup_cluster(n_cpus,cluster = None):
     from caiman import stop_server, cluster

{labdata-0.1.2 → labdata-0.1.4}/labdata/compute/suite2p.py

@@ -384,7 +384,8 @@ class Suite2pCompute(BaseCompute):
                     os.unlink(f)
         else:
             print(f'[{self.name} job] Kept the temporary folder {savedir}.')
-
+        for key in seskeys:
+            self.schema.CellSegmentationMetrics.populate(key,display_progress = True, processes = DEFAULT_N_JOBS)
 
 def extract_dff_fissa(stats,binary,dims,fs, batch_size,tau):
     '''

{labdata-0.1.2 → labdata-0.1.4}/labdata/dashboard/segmentation.py

@@ -4,8 +4,7 @@ import pandas as pd
 import streamlit as st
 import numpy as np
 
-MAX_PICKED = 5
-
+MAX_PLOT = 5
 
 def _normalize_image(img):
     img = np.asarray(img, dtype=float)
@@ -84,7 +83,7 @@ def segmentation_tab(schema=None):
 
     @st.cache_data
     def get_roi_color_proj(subject_name, session_name, dataset_name, parameter_set_num,
-                           sel_method, selected_only):
+                           sel_method, sel_label):
         from labdata.stacks import roi_color_projection
         key = dict(subject_name=subject_name, session_name=session_name,
                    dataset_name=dataset_name, parameter_set_num=parameter_set_num)
@@ -100,10 +99,10 @@ def segmentation_tab(schema=None):
             roi_nums = list(roi_table.fetch('roi_num'))
             if not roi_nums:
                 continue
-            if selected_only:
+            if sel_label is not None:
                 sel_rois = set(
                     (schema.CellSegmentation.Selection
-                     & dict(plane_key, selection_method=sel_method, selection=1)
+                     & dict(plane_key, selection_method=sel_method, selection=sel_label)
                     ).fetch('roi_num'))
                 cell_indices = [i for i, rn in enumerate(roi_nums) if rn in sel_rois]
             else:
@@ -126,6 +125,16 @@ def segmentation_tab(schema=None):
             (schema.CellSegmentation.Selection & key).fetch('selection_method')))
         return methods or ['auto']
 
+    @st.cache_data
+    def get_selection_labels(subject_name, session_name, dataset_name, parameter_set_num,
+                             sel_method):
+        key = dict(subject_name=subject_name, session_name=session_name,
+                   dataset_name=dataset_name, parameter_set_num=parameter_set_num,
+                   selection_method=sel_method)
+        vals = sorted(set(int(v) for v in
+                          (schema.CellSegmentation.Selection & key).fetch('selection')))
+        return vals
+
     @st.cache_data
     def get_roi_data(subject_name, session_name, dataset_name, parameter_set_num, sel_method):
         key = dict(subject_name=subject_name, session_name=session_name,
@@ -154,7 +163,8 @@ def segmentation_tab(schema=None):
             centers.append(dict(roi_num=r['roi_num'], plane_num=pnum,
                                 cy=float(np.median(rows_idx)),
                                 cx=float(np.median(cols_idx)),
-                                db_label=db_label))
+                                db_label=db_label,
+                                sel_value=is_cell))
         return centers
 
     @st.cache_data
@@ -441,17 +451,22 @@ def segmentation_tab(schema=None):
     if 'seg_sel_method_pending' in st.session_state:
         st.session_state['seg_sel_method'] = st.session_state.pop('seg_sel_method_pending')
 
-    cA, cB, cC, cD = st.columns([1, 1, 1, 2])
+    cA, cB, cC = st.columns([1, 1, 2])
     show_rois   = cA.toggle('Show ROI centers', value=True, key='seg_show_rois')
-    show_mode   = cB.radio('ROIs to show', ['All', 'Selected'], horizontal=True,
-                            key='seg_show_mode', label_visibility='collapsed')
-    show_traces = cC.toggle('Show traces', value=True, key='seg_show_traces')
-    sel_method  = cD.selectbox('Selection method', methods, key='seg_sel_method',
+    show_traces = cB.toggle('Show traces', value=True, key='seg_show_traces')
+    sel_method  = cC.selectbox('Selection method', methods, key='seg_sel_method',
                                 label_visibility='collapsed',
                                 disabled=not show_rois)
 
-    # Duplicate / delete selection methods
-    _, _, dC = st.columns([1, 1, 2])
+    # Duplicate / delete selection methods + label filter
+    sel_labels = get_selection_labels(
+        subject, row['session_name'], row['dataset_name'], param_set, sel_method)
+    lsT, lsS, _, dC = st.columns([0.4, 0.6, 1, 2])
+    lsT.markdown('<div style="padding-top:0.4em"><b>Selection:</b></div>',
+                 unsafe_allow_html=True)
+    sel_label_filter = lsS.selectbox(
+        'Filter by label', ['All'] + sel_labels,
+        key='seg_label_filter', label_visibility='collapsed')
     with dC:
         dname, dbtn, del_btn = st.columns([3, 1, 1])
         new_name = dname.text_input('New method name', key='seg_new_method_name',
@@ -511,7 +526,7 @@ def segmentation_tab(schema=None):
     with st.spinner('Loading ROI color projection…'):
         roi_color_projs = get_roi_color_proj(
             subject, row['session_name'], row['dataset_name'], param_set, sel_method,
-            selected_only=(show_mode == 'Selected'))
+            sel_label=None if sel_label_filter == 'All' else int(sel_label_filter))
 
     all_projections = roi_color_projs + list(projections)
 
@@ -522,18 +537,22 @@ def segmentation_tab(schema=None):
     size_domain  = ['cell', 'not cell', 'unclassified', 'picked']
     size_range   = [80, 80, 60, 160]
 
-    # Cell navigation (prev/next among all ROIs), sorted by SNR if possible
+    # Cell navigation: only iterate through displayed ROIs, sorted by SNR if possible
     snr_map = get_snr_map(subject, row['session_name'], row['dataset_name'], param_set)
+    displayed_centers = centers
+    if sel_label_filter != 'All':
+        displayed_centers = [c for c in displayed_centers
+                             if c['sel_value'] == int(sel_label_filter)]
     if snr_map:
         cell_list = sorted(
-            [(c['plane_num'], c['roi_num']) for c in centers],
+            [(c['plane_num'], c['roi_num']) for c in displayed_centers],
             key=lambda x: -(snr_map.get(x, {}).get('snr') or 0.0)
-        ) if centers else []
+        ) if displayed_centers else []
     else:
         cell_list = sorted(
-            [(c['plane_num'], c['roi_num']) for c in centers],
+            [(c['plane_num'], c['roi_num']) for c in displayed_centers],
             key=lambda x: (x[0], x[1])
-        ) if centers else []
+        ) if displayed_centers else []
 
     def _nav_cursor():
         """Return index of the last picked cell in cell_list, or -1."""
@@ -559,7 +578,7 @@ def segmentation_tab(schema=None):
         get_traces.clear()
         st.rerun()
 
-    # Keyboard shortcuts: p/ArrowLeft = prev, n/ArrowRight = next
+    # Keyboard: w or p/s or n = prev/next cell, d/a = time forward/back
     _kb_html = """
 <script>
 (function() {
@@ -569,8 +588,10 @@ def segmentation_tab(schema=None):
     parent.addEventListener('keydown', function(e) {
         if (e.target && (e.target.tagName === 'INPUT' || e.target.tagName === 'TEXTAREA')) return;
         var label = null;
-        if (e.key === 'n' || e.key === 'ArrowRight') label = 'next cell';
-        if (e.key === 'p' || e.key === 'ArrowLeft')  label = 'prev cell';
+        if ((e.key === 'w') ||  (e.key === 'p')) label = 'prev cell';
+        if ((e.key === 's') ||  (e.key === 'n')) label = 'next cell';
+        if (e.key === 'd') label = '+';
+        if (e.key === 'a') label = '-';
         if (!label) return;
         var btns = parent.querySelectorAll('button');
         for (var i = 0; i < btns.length; i++) {
@@ -586,7 +607,7 @@ def segmentation_tab(schema=None):
         import streamlit.components.v1 as _stc
         _stc.html(_kb_html, height=0)
 
-    # projection tabs — 'roi color' first (default), then others sorted
+    # projection tabs 
     _other_names = sorted(set(r['proj_name'] for r in projections))
     proj_names = (['roi color'] if roi_color_projs else []) + _other_names
     if not proj_names:
@@ -619,12 +640,13 @@ def segmentation_tab(schema=None):
                 scatter = None
                 if show_rois and plane_centers:
                     picked_set = {(p['plane_num'], p['roi_num']) for p in picked}
-                    visible = (
-                        [c for c in plane_centers
-                         if c['db_label'] == 'cell'
-                         or (c['plane_num'], c['roi_num']) in picked_set]
-                        if show_mode == 'Selected' else plane_centers
-                    )
+                    if sel_label_filter == 'All':
+                        visible = plane_centers
+                    else:
+                        lf = int(sel_label_filter)
+                        visible = [c for c in plane_centers
+                                   if c['sel_value'] == lf
+                                   or (c['plane_num'], c['roi_num']) in picked_set]
                     if visible:
                         roi_df = pd.DataFrame(visible)
                         roi_df['status'] = roi_df.apply(
@@ -694,7 +716,7 @@ def segmentation_tab(schema=None):
 
     st.divider()
 
-    plot_picked = picked[-MAX_PICKED:]
+    plot_picked = picked[-MAX_PLOT:]
 
     hA, hB = st.columns([3, 1])
     hA.write(f'**ROIs** (plotting last {len(plot_picked)} of {len(picked)} selected): '
@@ -736,50 +758,77 @@ def segmentation_tab(schema=None):
             frame_rate, _ = get_frame_rate(subject, row['session_name'], row['dataset_name'])
             traces_df = traces_df.copy()
             traces_df['t_sec'] = traces_df['t'] / frame_rate
-
             y_min = min(0.0, float(traces_df['value'].min()))
             y_max = float(traces_df['value'].max())
-
             window_s = 300.0
             total_s = float(traces_df['t_sec'].max())
-            if total_s > window_s:
-                max_start = round(total_s - window_s, 2)
-                _lc, _sc = st.columns([1, 11])
-                _lc.markdown('**Time (s)**')
-                t_start = _sc.slider('Time (s)', 0.0, max_start, 0.0, step=30.0,
-                                     key='seg_trace_window', label_visibility='collapsed')
-            else:
-                t_start = 0.0
-            t_end = t_start + window_s
-
-            view_df = traces_df[
-                (traces_df['t_sec'] >= t_start) & (traces_df['t_sec'] <= t_end)]
-            trace_chart = (
-                alt.Chart(view_df)
-                .mark_line(strokeWidth=1.2)
-                .encode(
-                    x=alt.X('t_sec:Q', title='Time (s)',
-                             scale=alt.Scale(domain=[t_start, t_end]),
-                             axis=alt.Axis(tickCount=5, tickSize=5, grid=False)),
-                    y=alt.Y('value:Q', title=trace_type,
-                             scale=alt.Scale(domain=[y_min-0.1, y_max+0.1]),
-                             axis=alt.Axis(tickCount=5, tickSize=5, grid=False)),
-                    color=alt.Color('roi:N', title='ROI',
-                                    scale=alt.Scale(domain=roi_labels, range=roi_color_range)),
-                    tooltip=['roi:N', alt.Tooltip('t_sec:Q', title='Time (s)', format='.2f'),
-                             alt.Tooltip('value:Q', format='.4f')],
+
+            def _draw_traces():
+                if total_s > window_s:
+                    max_start = round(total_s - window_s, 2)
+                    _lc, _tb, _sc, _tf = st.columns([1, 0.2, 10, 0.2])
+                    _lc.markdown('**Time (s)**')
+                    if _tb.button('-', key='seg_time_back', use_container_width=True):
+                        cur = st.session_state.get('seg_trace_window', 0.0)
+                        st.session_state['seg_trace_window'] = max(0.0, cur - window_s/2)
+                        _rerun()
+                    if _tf.button('+', key='seg_time_fwd', use_container_width=True):
+                        cur = st.session_state.get('seg_trace_window', 0.0)
+                        st.session_state['seg_trace_window'] = min(max_start, cur + window_s/2)
+                        _rerun()
+                    t_start = _sc.slider('Time (s)', 0.0, max_start,
+                                         st.session_state.get('seg_trace_window', 0.0),
+                                         step=30.0, key='seg_trace_window',
+                                         label_visibility='collapsed')
+                else:
+                    t_start = 0.0
+                t_end = t_start + window_s
+                view_df = traces_df[
+                    (traces_df['t_sec'] >= t_start) & (traces_df['t_sec'] <= t_end)]
+                trace_chart = (
+                    alt.Chart(view_df)
+                    .mark_line(strokeWidth=1.2)
+                    .encode(
+                        x=alt.X('t_sec:Q', title='Time (s)',
+                                 scale=alt.Scale(domain=[t_start, t_end]),
+                                 axis=alt.Axis(tickCount=5, tickSize=5, grid=False)),
+                        y=alt.Y('value:Q', title=trace_type,
+                                 scale=alt.Scale(domain=[y_min-0.1, y_max+0.1]),
+                                 axis=alt.Axis(tickCount=5, tickSize=5, grid=False)),
+                        color=alt.Color('roi:N', title='ROI',
+                                        scale=alt.Scale(domain=roi_labels,
+                                                        range=roi_color_range)),
+                        tooltip=['roi:N',
+                                 alt.Tooltip('t_sec:Q', title='Time (s)', format='.2f'),
+                                 alt.Tooltip('value:Q', format='.4f')],
+                    )
+                    .properties(height=220).interactive()
                 )
-                .properties(height=220).interactive()
-            )
-            st.altair_chart(trace_chart, width='stretch')
+                st.altair_chart(trace_chart, width='stretch')
+
+            if hasattr(st, 'fragment'):
+                def _rerun(): st.rerun(scope='fragment')
+                st.fragment(_draw_traces)()
+            else:
+                def _rerun(): st.rerun()
+                _draw_traces()
 
-    # classification editor — shows currently picked cells + any cells whose
+    # classification editor — shows currently picked cells and cells whose
     # classification was changed from the original value
     st.write('**ROI classification**')
+
+    # avoid second re-run
+    if st.session_state.pop('_seg_propagate_pending', False):
+        pv = st.session_state.pop('_seg_propagate_val', None)
+        if pv is not None:
+            st.session_state['seg_editor_rows'] = [
+                dict(r, selection=pv) for r in st.session_state['seg_editor_rows']]
+            st.session_state.pop('seg_selection_editor', None)
+
     editor_rows = list(st.session_state['seg_editor_rows'])
     picked_keys = {(p['plane_num'], p['roi_num']) for p in picked}
 
-    # pending widget edits into editor_rows so filtering sees the current values
+    # pending editor_rows so filtering sees the current values
     widget_edits = (st.session_state.get('seg_selection_editor') or {}).get('edited_rows', {})
     for i in range(len(editor_rows)):
         edits = widget_edits.get(i, widget_edits.get(str(i), {}))
@@ -788,7 +837,7 @@ def segmentation_tab(schema=None):
 
     # currently picked cells OR cells whose classification changed from the original
     editor_rows = [r for r in editor_rows
-                   if (r['plane'], r['roi']) in picked_keys or r['is_cell'] != r['_orig']]
+                   if (r['plane'], r['roi']) in picked_keys or r['selection'] != r['_orig']]
 
     # Add picked cells not yet in the list
     existing = {(r['plane'], r['roi']) for r in editor_rows}
@@ -798,9 +847,9 @@ def segmentation_tab(schema=None):
             entry = (schema.CellSegmentation.Selection
                      & dict(roi_key, selection_method=sel_method)).fetch(
                 'selection', as_dict=True)
-            orig = bool(entry[0]['selection']) if entry else None
+            orig = int(entry[0]['selection']) if entry else None
             editor_rows.append({'plane': plane_num, 'roi': roi_num,
-                                 'method': sel_method, 'is_cell': orig, '_orig': orig})
+                                 'method': sel_method, 'selection': orig, '_orig': orig})
             existing.add((plane_num, roi_num))
 
     if editor_rows != st.session_state['seg_editor_rows']:
@@ -830,48 +879,52 @@ def segmentation_tab(schema=None):
     editor_display = pd.DataFrame([
         {'●': _color_swatch(roi_color_map.get(f'plane {r["plane"]}, roi {r["roi"]}', '#888888')),
          **({'□': crop_map.get((r['plane'], r['roi']))} if crop_map else {}),
-         'plane': r['plane'], 'roi': r['roi'], 'method': r['method'], 'is_cell': r['is_cell'],
+         'plane': r['plane'], 'roi': r['roi'], 'method': r['method'],
+         'selection': r['selection'],
          **({
-             'diam': _fmt(snr_map.get((r['plane'], r['roi']), {}).get('diameter')),
-             'AR':   _fmt(snr_map.get((r['plane'], r['roi']), {}).get('aspect_ratio')),
-             'skew': _fmt(snr_map.get((r['plane'], r['roi']), {}).get('trace_skewness')),
-             'noise':_fmt(snr_map.get((r['plane'], r['roi']), {}).get('noise_level')),
+             'snr':   _fmt(snr_map.get((r['plane'], r['roi']), {}).get('snr')),
+             'diam':  _fmt(snr_map.get((r['plane'], r['roi']), {}).get('diameter')),
+             'aspect':_fmt(snr_map.get((r['plane'], r['roi']), {}).get('aspect_ratio')),
+             'skew':  _fmt(snr_map.get((r['plane'], r['roi']), {}).get('trace_skewness')),
+             'noise': _fmt(snr_map.get((r['plane'], r['roi']), {}).get('noise_level')),
          } if snr_map else {})}
         for r in editor_rows
     ]) if editor_rows else pd.DataFrame(
-        columns=['●'] + (['□'] if crop_map else []) + ['plane', 'roi', 'method', 'is_cell']
-                + (['diam', 'AR', 'skew', 'noise'] if snr_map else []))
+        columns=['●'] + (['□'] if crop_map else []) + ['plane', 'roi', 'method', 'selection']
+                + (['snr', 'diam', 'aspect', 'skew', 'noise'] if snr_map else []))
 
     _crop_col_cfg = {'□': st.column_config.ImageColumn('ROI', width='small')} if crop_map else {}
     _metrics_col_cfg = {
+        'snr':   st.column_config.NumberColumn('SNR',      format='%.1f', width='small'),
         'diam':  st.column_config.NumberColumn('diam (px)', format='%.1f', width='small'),
-        'AR':    st.column_config.NumberColumn('AR',        format='%.2f', width='small'),
-        'skew':  st.column_config.NumberColumn('skew',      format='%.2f', width='small'),
-        'noise': st.column_config.NumberColumn('noise',     format='%.3f', width='small'),
+        'aspect':st.column_config.NumberColumn('aspect',   format='%.2f', width='small'),
+        'skew':  st.column_config.NumberColumn('skew',     format='%.2f', width='small'),
+        'noise': st.column_config.NumberColumn('noise',    format='%.3f', width='small'),
     } if snr_map else {}
     edited = st.data_editor(
         editor_display, hide_index=True, width='stretch',
         column_config={
             '●': st.column_config.ImageColumn(' ', width='small'),
             **_crop_col_cfg,
-            'is_cell': st.column_config.CheckboxColumn('Is cell?', width='small'),
+            'selection': st.column_config.NumberColumn('selection', step=1, width='small'),
             **_metrics_col_cfg,
         },
-        disabled=['●', '□', 'plane', 'roi', 'method', 'diam', 'AR', 'skew', 'noise'],
+        disabled=['●', '□', 'plane', 'roi', 'method', 'snr', 'diam', 'aspect', 'skew', 'noise'],
         key='seg_selection_editor',
     )
 
-    if st.button('Save classification', key='seg_save_selection'):
+    def _do_save(df):
         changed = 0
-        for _, erow in edited.iterrows():
-            if erow['is_cell'] is None:
+        for _, erow in df.iterrows():
+            raw = erow.get('selection')
+            if raw is None:
                 continue
             roi_key = dict(seg_key, plane_num=int(erow['plane']),
                            roi_num=int(erow['roi']),
                            selection_method=sel_method)
             try:
                 schema.CellSegmentation.Selection.update1(
-                    {**roi_key, 'selection': 1 if erow['is_cell'] else 0})
+                    {**roi_key, 'selection': int(raw)})
                 changed += 1
             except Exception as exc:
                 st.error(f'Error updating plane {erow["plane"]} roi {erow["roi"]}: {exc}')
@@ -883,3 +936,12 @@ def segmentation_tab(schema=None):
             st.session_state.pop('seg_selection_editor', None)
             st.rerun()
 
+    _bA, _bB = st.columns([1, 1])
+    if _bA.button('Save classification', key='seg_save_selection'):
+        _do_save(edited)
+    if _bB.button('Propagate first', key='seg_propagate_first',
+                  disabled=edited.empty or bool(edited['selection'].isna().all())):
+        first_val = int(edited['selection'].dropna().iloc[0])
+        st.session_state['_seg_propagate_pending'] = True
+        st.session_state['_seg_propagate_val'] = first_val
+

{labdata-0.1.2 → labdata-0.1.4}/labdata.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: labdata
-Version: 0.1.2
+Version: 0.1.4
 Summary: Package to manage data in experimental neuroscience labs
 Author-email: Joao Couto <jpcouto@gmail.com>
 Project-URL: Homepage, https://github.com/jcouto/labdata