labdata 0.1.2__tar.gz → 0.1.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: labdata
-Version: 0.1.2
+Version: 0.1.3
 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.3}/labdata/__init__.py

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

{labdata-0.1.2 → labdata-0.1.3}/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.3}/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.3}/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)
@@ -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'))
+            selected_only=(sel_label_filter != 'All'))
 
     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): '
@@ -744,10 +766,20 @@ def segmentation_tab(schema=None):
             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, _tb, _sc, _tf = st.columns([1, 0.2, 10, 0.2])
                 _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')
+                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)
+                    st.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)
+                    st.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
@@ -773,7 +805,7 @@ def segmentation_tab(schema=None):
             )
             st.altair_chart(trace_chart, width='stretch')
 
-    # 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**')
     editor_rows = list(st.session_state['seg_editor_rows'])
@@ -788,7 +820,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 +830,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 +862,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 +919,14 @@ 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 edited['selection'].isna().all()):
+        first_val = int(edited['selection'].dropna().iloc[0])
+        updated = [dict(r, selection=first_val) for r in editor_rows]
+        st.session_state['seg_editor_rows'] = updated
+        st.session_state.pop('seg_selection_editor', None)
+        st.rerun()
+

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

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