regrender 0.1.0__py3-none-any.whl

regrender/main_roi.py

@@ -0,0 +1,489 @@
+"""ROI labeling + projection.
+
+Workflow order is **roi → register → project**. ROIs (cells) are labelled on the *full
+resolution* raw histology (you need the detail to see them) and saved in **raw pixel**
+coords, independent of any registration. Once the slice is registered (`regrender register`),
+the saved transform is applied to those raw coords to project them into the down-sampled
+Allen atlas / CCF space, then reconstructed with brainrender. Projection is a single
+function used by both the GUI "Project + Render" button and the headless ``--project`` CLI.
+"""
+from __future__ import annotations
+
+import tempfile
+from collections import defaultdict
+from pathlib import Path
+
+import numpy as np
+import polars as pl
+from argclz import argument
+from brainglobe_atlasapi import BrainGlobeAtlas
+from neuralib.atlas.ccf.matrix import slice_transform_helper
+from neuralib.atlas.util import ALLEN_CCF_10um_BREGMA
+
+from regrender._app import RegionPicker, SliceReconstructOptions, printf
+from regrender._core import (
+    boundary_mask,
+    load_transform,
+    plane_point_to_ccf_mm,
+    raw_points_to_atlas,
+    read_oriented,
+    region_name,
+    rotate,
+)
+
+__all__ = ['RoiOptions', 'project_raw_rois']
+
+_COLORS = ['orange', 'magenta', 'red', 'cyan', 'yellow', 'lime', 'green', 'blue', 'white', 'dimgray']
+SHADER_STYLES = ['plastic', 'cartoon', 'metallic', 'shiny', 'glossy']
+CAMERA_ANGLES = ['three_quarters', 'sagittal', 'sagittal2', 'frontal', 'top', 'top_side']
+
+RAW_COLS = ('slice', 'x', 'y', 'raw_h', 'raw_w')  # saved raw-ROI csv schema (channel optional, added on save)
+# per-channel cross / render color; 'merge' overridden by the GUI ROI-color picker
+_CH_COLOR = {'merge': 'cyan', 'R': 'red', 'G': 'green', 'B': 'blue'}
+
+
+def project_raw_rois(rows, get_views, structures, transform_for):
+    """Project raw-pixel ROIs into Allen CCF mm.
+
+    :param rows: dicts with keys ``slice, x, y, raw_h, raw_w`` (raw image pixels + shape), optional ``channel``.
+    :param get_views: ``(plane, res) -> (reference_view, annotation_view)`` (see make_view_cache).
+    :param structures: BrainGlobe structures (for region acronyms).
+    :param transform_for: ``slice_stem -> meta dict`` (the saved transform) or ``None`` if unregistered.
+    :return: ``(ccf_rows, missing_slices)`` — ccf_rows have AP/DV/ML_location + region + source + channel.
+    """
+    by_slice: dict[str, list] = defaultdict(list)
+    for r in rows:
+        by_slice[r['slice']].append(r)
+
+    ccf_rows, missing = [], []
+    for stem, rs in by_slice.items():
+        meta = transform_for(stem)
+        if meta is None:
+            missing.append(stem)
+            continue
+        plane, res = meta['plane'], int(meta['resolution'])
+        idx, dw, dh = int(meta['slice_index']), int(meta['dw']), int(meta['dh'])
+        view, ann = get_views(plane, res)
+        od = lambda v: v + 1 if v != 0 else 0
+        off = view.plane_at(idx).with_offset(od(dw), od(dh)).plane_offset
+        ann_img = ann.plane_at(idx).with_offset(od(dw), od(dh)).image
+
+        raw_shape = (int(rs[0]['raw_h']), int(rs[0]['raw_w']))  # constant per slice
+        atlas = raw_points_to_atlas(
+            [[r['x'], r['y']] for r in rs], matrix=np.array(meta['matrix'], float),
+            raw_shape=raw_shape, plane=plane, rotate_deg=float(meta.get('rotate', 0.0)),
+            flip_lr=meta.get('flip_lr', False), flip_ud=meta.get('flip_ud', False))
+        for r, (ax, ay) in zip(rs, atlas):  # rs and atlas stay aligned (same order)
+            xi, yi = int(round(ax)), int(round(ay))
+            if not (0 <= yi < off.shape[0] and 0 <= xi < off.shape[1]):
+                continue  # mapped outside the atlas plane
+            ap, dv, ml = plane_point_to_ccf_mm(off[yi, xi], ax, ay, project_index=view.project_index,
+                                               resolution=view.resolution,
+                                               bregma_10um=tuple(ALLEN_CCF_10um_BREGMA))
+            acr = region_name(ann_img, structures, ay, ax).split(' — ')[0]
+            ccf_rows.append({'AP_location': ap, 'DV_location': dv, 'ML_location': ml,
+                             'region': acr, 'source': stem, 'channel': r.get('channel', 'merge')})
+    return ccf_rows, missing
+
+
+def _render_tmpdir() -> Path:
+    # per-channel render inputs live in a throwaway temp dir; the OS reaps it, the data folder stays clean
+    return Path(tempfile.mkdtemp(prefix='regrender_roi_'))  # not cleaned up: a few KB in /tmp per render
+
+
+def write_channel_csvs(ccf_rows, dest_dir: Path) -> list[tuple[str, Path]]:
+    """Split projected rows into one plain CCF csv per channel inside ``dest_dir`` (brainrender
+    renders one --file per color). These are render inputs, not user artifacts — pass a temp dir.
+    Returns ``[(channel, path), ...]`` in stable channel order."""
+    groups: dict[str, list] = defaultdict(list)
+    for r in ccf_rows:
+        groups[r.get('channel', 'merge')].append(r)
+    cols = ('AP_location', 'DV_location', 'ML_location', 'region', 'source')
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    out = []
+    for ch in sorted(groups):
+        p = dest_dir / f'roi_ccf_{ch}.csv'
+        pl.DataFrame([{k: r[k] for k in cols} for r in groups[ch]]).write_csv(p)
+        out.append((ch, p))
+    return out
+
+
+def _render_argv(channel_files: list[tuple[str, Path]], radius: float, ch_color: dict[str, str],
+                 region_colors: dict[str, str], style: str, no_root: bool, hemisphere: str,
+                 camera: str = CAMERA_ANGLES[0]) -> list[str]:
+    """``RoiRenderCLI`` argv (after ``-m``): one --file per channel + matching colors + region meshes."""
+    cmd = ['neuralib.atlas.brainrender.roi']
+    colors = []
+    for ch, p in channel_files:
+        cmd += ['--file', str(p)]
+        colors.append(ch_color.get(ch, 'orange'))
+    cmd += ['--roi-colors', ','.join(colors), '--roi-radius', str(radius),
+            '--style', style, '--hemisphere', hemisphere, '--camera', camera]
+    if no_root:
+        cmd.append('--no-root')
+    if region_colors:
+        cmd += ['--region', ','.join(region_colors)]
+        cmd += ['--region-color', ','.join(region_colors.values())]
+    return cmd
+
+
+class RoiOptions(SliceReconstructOptions):
+    DESCRIPTION = ('Label ROIs (cells) on the full-res raw histology and save them in raw pixel '
+                   'coords. After registration, project them into Allen CCF space and render '
+                   '(GUI button or `--project`).')
+
+    project: bool = argument('--project',
+                             help='headless: project a saved raw-ROI CSV into CCF space (no GUI)')
+    render: bool = argument('--render', help='with --project, also launch brainrender')
+    roi_radius: float = argument('--roi-radius', default=30, help='rendered ROI sphere radius (µm)')
+    roi_color: str = argument('--roi-color', default='orange', help='rendered ROI point color')
+
+    def run(self):
+        if self.project:
+            self._run_project_headless()
+            return
+        files = self._resolve_paths('roi/roi_points_raw.csv', require_transform=False)
+        self._launch_napari(files)
+
+    def _ccf_out(self) -> Path:
+        return self._out.with_name('roi_points_ccf.csv')
+
+    def _transform_for(self, stem: str):
+        p = self._tdir / f'{stem}_transform.json'
+        return load_transform(p) if p.exists() else None
+
+    def _project_and_save(self, rows, get_views, structures, status=None):
+        """Shared projection: raw rows -> combined CCF csv. Returns ``(path, ccf_rows)`` or ``None``."""
+        ccf_rows, missing = project_raw_rois(rows, get_views, structures, self._transform_for)
+        msg = lambda m: status.__setattr__('value', m) if status is not None else printf(m)
+        if missing:
+            msg(f'no registration for slice(s): {", ".join(sorted(set(missing)))} — register them first')
+        if not ccf_rows:
+            msg('nothing projected (no registered ROIs)')
+            return None
+        out = self._ccf_out()
+        out.parent.mkdir(parents=True, exist_ok=True)
+        pl.DataFrame(ccf_rows).write_csv(out)  # combined artifact (with channel column)
+        msg(f'projected {len(ccf_rows)} ROI(s) -> {out}')  # full path; GUI mirrors it to the terminal
+        return out, ccf_rows
+
+    def _run_project_headless(self):
+        # resolve the raw csv input + transform dir without needing the images
+        raw_csv = self.output or (
+            (self.directory or (self.raw_image.parent if self.raw_image else Path.cwd()))
+            / 'roi' / 'roi_points_raw.csv')
+        base = self.directory or (self.raw_image.parent if self.raw_image else raw_csv.parent)
+        self._tdir = self.transform_dir or base / 'transformations'
+        self._out = raw_csv
+        if not raw_csv.exists():
+            raise FileNotFoundError(f'no raw-ROI csv {raw_csv} — label ROIs with `regrender roi` first')
+
+        df = pl.read_csv(raw_csv)
+        if not set(RAW_COLS) <= set(df.columns):
+            raise ValueError(f'{raw_csv.name}: not a raw-ROI csv (needs {", ".join(RAW_COLS)})')
+        get_views = self.make_view_cache()
+        structures = BrainGlobeAtlas('allen_mouse_10um', check_latest=False).structures
+        res = self._project_and_save(df.to_dicts(), get_views, structures)
+        if res is not None and self.render:
+            _, ccf_rows = res
+            ch_files = write_channel_csvs(ccf_rows, _render_tmpdir())  # per-channel render inputs (temp)
+            ch_color = {**_CH_COLOR, 'merge': self.roi_color}
+            self.launch_render(_render_argv(ch_files, self.roi_radius, ch_color, {},
+                                            SHADER_STYLES[0], False, 'both'))
+            printf(f'rendering {len(ch_files)} channel(s) in a separate window...')
+
+    def _launch_napari(self, files: list[Path]):
+        import napari
+        from magicgui.widgets import CheckBox, ComboBox, Container, Label, PushButton
+
+        viewer = napari.Viewer(title='regrender roi')
+        viewer.camera.mouse_pan = False  # left-drag must add ROIs, not pan the slice; scroll still zooms
+        viewer.text_overlay.visible = True  # region name under cursor (verify mode)
+        viewer.text_overlay.font_size = 18
+        viewer.text_overlay.color = 'yellow'
+
+        bg = BrainGlobeAtlas('allen_mouse_10um', check_latest=False)
+        get_views = self.make_view_cache()  # lazy: atlas volumes load only on first Project/Verify
+
+        # rois[id] = {'slice': stem, 'raw': (y, x)}; shapes[stem] = (H, W)
+        state: dict = {'rois': {}, 'next_id': 1, 'shapes': {}, 'files': files, 'cursor': 0,
+                       'name': None, 'path': None, 'raw_img': None, 'verify': False,
+                       'ann_img': None, 'hover_id': None}
+
+        from napari.utils import Colormap
+        raw_layer = None  # image layer, re-created per slice (grayscale<->RGB safe)
+        roi_layer = viewer.add_points(name='rois', face_color='cyan', symbol='cross', size=20, ndim=2)
+        hcmap = Colormap([[0, 0, 0], [0.3, 0.6, 1.0]], name='highlight')
+        highlight_layer = viewer.add_image(np.zeros((10, 10), dtype=float), name='region_highlight',
+                                           colormap=hcmap, blending='additive', opacity=0.4)
+        bound_layer = viewer.add_image(np.zeros((10, 10)), name='boundaries', colormap='red',
+                                       blending='additive', opacity=0.7)
+        highlight_layer.visible = bound_layer.visible = False  # atlas overlays: verify mode only
+        viewer.layers.selection.active = roi_layer
+        roi_layer.mode = 'add'
+
+        def select_roi_layer():
+            viewer.layers.selection.active = roi_layer  # adding the image layer steals focus
+            roi_layer.mode = 'add'
+
+        def set_raw(img: np.ndarray):
+            nonlocal raw_layer
+            if raw_layer is not None and raw_layer in viewer.layers:
+                viewer.layers.remove(raw_layer)
+            raw_layer = viewer.add_image(img, name='histology', colormap='gray')
+
+        def reorder():  # bottom -> top: image, region highlight, atlas boundaries, ROI crosses
+            for i, lyr in enumerate(l for l in (raw_layer, highlight_layer, bound_layer, roi_layer)
+                                    if l is not None and l in viewer.layers):
+                viewer.layers.move(viewer.layers.index(lyr), i)
+
+        status_label, status = self.make_status_log()
+        status.value = 'load a raw slice and click cells (no registration needed yet)'
+        summary = Label(value='')
+        summary.native.setWordWrap(True)
+        summary.native.setStyleSheet('font-family: Menlo, Consolas, monospace; font-size: 12px;')
+        slice_lbl = Label(value='no slice loaded')
+        slice_lbl.native.setWordWrap(True)
+
+        def set_crosses(yx_list, colors=None):
+            # programmatic refresh of the layer; guarded so it doesn't re-enter sync_from_layer
+            state['loading'] = True
+            roi_layer.selected_data = set()  # drop any selection; stale indices crash on data swap
+            roi_layer.data = np.array(yx_list) if yx_list else np.empty((0, 2))
+            if yx_list and colors is not None:
+                roi_layer.face_color = colors  # per-point (per-channel) colors
+            state['loading'] = False
+
+        def sync_from_layer(*_):
+            # user added/removed points in raw add mode; resync this (slice, channel) subset only
+            if state.get('loading') or state['verify'] or state['name'] is None:
+                return
+            stem, ch = state['name'], channel_w.value
+            state['rois'] = {i: r for i, r in state['rois'].items()
+                             if not (r['slice'] == stem and r.get('channel', 'merge') == ch)}
+            for y, x in roi_layer.data:
+                rid = state['next_id']
+                state['next_id'] += 1
+                state['rois'][rid] = {'slice': stem, 'raw': (float(y), float(x)), 'channel': ch}
+            refresh_summary()
+            status.value = f'{stem} [{ch}]: {len(roi_layer.data)} ROI(s)'
+
+        roi_layer.events.data.connect(sync_from_layer)
+        viewer.mouse_move_callbacks.append(self.make_hover(viewer, state, bg.structures, highlight_layer))
+
+        def _slice_rois(channel=None):
+            # ROIs on the current slice; channel=None -> all channels, else just that channel
+            return [r for r in state['rois'].values() if r['slice'] == state['name']
+                    and (channel is None or r.get('channel', 'merge') == channel)]
+
+        def display_raw():
+            # annotation view: native raw image, click to add ROIs in the active channel's set
+            ch = channel_w.value
+            state['ann_img'] = None
+            set_raw(self.channel_view(state['raw_img'], ch))
+            highlight_layer.visible = bound_layer.visible = False
+            rois = _slice_rois(ch)
+            color = _CH_COLOR.get(ch, 'cyan')
+            set_crosses([r['raw'] for r in rois], [color] * len(rois))
+            roi_layer.current_face_color = color  # newly clicked ROIs take the channel color
+            reorder()
+            select_roi_layer()
+            viewer.camera.mouse_pan = pan_w.value
+            status.value = (f'{state["path"].name} [{ch}]: click to add cells (scroll=zoom) — '
+                            f'{len(rois)} in this channel')
+
+        def display_warped():
+            # verify view: transformed (atlas-aligned) image + boundaries + projected ROI crosses
+            meta = self._transform_for(state['name'])
+            if meta is None:
+                status.value = f'no registration for {state["name"]} — register it first'
+                verify_w.value = False  # handler switches back to the raw view
+                return
+            plane, res = meta['plane'], int(meta['resolution'])
+            idx, dw, dh = int(meta['slice_index']), int(meta['dw']), int(meta['dh'])
+            oimg = rotate(read_oriented(state['path'], meta.get('flip_lr', False),
+                                        meta.get('flip_ud', False)), float(meta.get('rotate', 0.0)))
+            _, warped = slice_transform_helper(oimg, np.array(meta['matrix'], float), plane_type=plane)
+            od = lambda v: v + 1 if v != 0 else 0
+            view, ann = get_views(plane, res)
+            ann_img = ann.plane_at(idx).with_offset(od(dw), od(dh)).image
+            state['ann_img'], state['hover_id'] = ann_img, None
+            set_raw(warped)
+            bound_layer.data = boundary_mask(ann_img)
+            highlight_layer.data = np.zeros(ann_img.shape, dtype=float)
+            highlight_layer.visible = bound_layer.visible = True
+
+            rois, shape = _slice_rois(), state['shapes'].get(state['name'])  # all channels, colored per channel
+            here, cols = [], []
+            if rois and shape is not None:  # raw (y,x) -> atlas (x,y); cross goes at (y_atlas, x_atlas)
+                atlas = raw_points_to_atlas([[r['raw'][1], r['raw'][0]] for r in rois],
+                                            matrix=np.array(meta['matrix'], float), raw_shape=shape,
+                                            plane=plane, rotate_deg=float(meta.get('rotate', 0.0)),
+                                            flip_lr=meta.get('flip_lr', False), flip_ud=meta.get('flip_ud', False))
+                here = [[ay, ax] for ax, ay in atlas]
+                cols = [_CH_COLOR.get(r.get('channel', 'merge'), 'cyan') for r in rois]
+            set_crosses(here, cols)
+            roi_layer.mode = 'pan_zoom'  # atlas space is read-only
+            reorder()
+            viewer.camera.mouse_pan = True
+            status.value = f'{state["name"]}: {len(here)} ROI(s) on the transformed slice (verify)'
+
+        def display_slice():
+            (display_warped if state['verify'] else display_raw)()
+
+        def load_slice(img: Path):
+            state['path'], state['name'] = img, img.stem
+            state['raw_img'] = read_oriented(img, flip_lr=False, flip_ud=False)  # native; flips at projection
+            state['shapes'][img.stem] = state['raw_img'].shape[:2]
+            files = state['files']
+            pos = f'{state["cursor"] + 1}/{len(files)}  ' if files else ''
+            slice_lbl.value = f'{pos}{img.name}'
+            display_slice()
+            viewer.reset_view()
+
+        def refresh_summary():
+            if not state['rois']:
+                summary.value = 'no ROIs yet'
+                return
+            per_ch = defaultdict(int)
+            for r in state['rois'].values():
+                per_ch[r.get('channel', 'merge')] += 1
+            chans = '  '.join(f'{c}:{per_ch[c]}' for c in sorted(per_ch))
+            summary.value = f'<b>total {len(state["rois"])}</b><br>{chans}'
+
+        def remove_last():
+            if state['verify']:
+                status.value = 'switch off Verify to edit ROIs'
+                return
+            if state['name'] is None or len(roi_layer.data) == 0:
+                status.value = 'no ROI on this slice to undo'
+                return
+            roi_layer.data = roi_layer.data[:-1]  # triggers sync_from_layer to resync state
+
+        regions = RegionPicker(bg.structures)
+        style_w = ComboBox(label='style', choices=SHADER_STYLES, value=SHADER_STYLES[0])
+        hemisphere_w = ComboBox(label='hemisphere', choices=['both', 'left', 'right'], value='both')
+        camera_w = ComboBox(label='camera', choices=CAMERA_ANGLES, value=CAMERA_ANGLES[0])
+        no_root_w = CheckBox(label='no root (hide brain)', value=False)
+        color_w = ComboBox(label='ROI color', choices=_COLORS,
+                           value=self.roi_color if self.roi_color in _COLORS else _COLORS[0])
+
+        def rows_from_state() -> list[dict]:
+            out = []
+            for r in state['rois'].values():
+                h, w = state['shapes'].get(r['slice'], (None, None))
+                y, x = r['raw']
+                out.append({'slice': r['slice'], 'x': x, 'y': y, 'raw_h': h, 'raw_w': w,
+                            'channel': r.get('channel', 'merge')})
+            return out
+
+        def save_csv() -> Path | None:
+            if not state['rois']:
+                status.value = 'no ROIs to save'
+                return None
+            self._out.parent.mkdir(parents=True, exist_ok=True)
+            pl.DataFrame(rows_from_state()).write_csv(self._out)
+            status.value = f'saved {len(state["rois"])} raw ROI(s) -> {self._out}'
+            return self._out
+
+        def load_csv_points(path: Path):
+            try:
+                df = pl.read_csv(path)
+            except Exception as e:  # noqa: BLE001 - surface any read error in the GUI
+                status.value = f'could not read {path.name}: {e}'
+                return
+            if not set(RAW_COLS) <= set(df.columns):
+                status.value = f'{path.name}: not a raw-ROI csv (needs {", ".join(RAW_COLS)})'
+                return
+            for r in df.iter_rows(named=True):
+                rid = state['next_id']
+                state['next_id'] += 1
+                state['rois'][rid] = {'slice': r['slice'], 'raw': (r['y'], r['x']),
+                                      'channel': r.get('channel', 'merge')}  # back-compat: old csvs -> merge
+                state['shapes'].setdefault(r['slice'], (r['raw_h'], r['raw_w']))
+            refresh_summary()
+            if state['name'] is not None:
+                display_slice()  # refresh crosses in whichever view is active
+            status.value = f'loaded {len(df)} raw ROI(s) from {path.name}'
+
+        def on_project():
+            save_csv()  # persist raw coords first
+            res = self._project_and_save(rows_from_state(), get_views, bg.structures, status)
+            if res is not None:
+                _, ccf_rows = res
+                ch_files = write_channel_csvs(ccf_rows, _render_tmpdir())  # per-channel render inputs (temp)
+                ch_color = {**_CH_COLOR, 'merge': color_w.value}
+                self.launch_render(
+                    _render_argv(ch_files, self.roi_radius, ch_color, regions.colors,
+                                 style_w.value, no_root_w.value, hemisphere_w.value, camera_w.value),
+                    status, f'rendering {len(ccf_rows)} ROI(s) across {len(ch_files)} channel(s)...')
+
+        def step(delta: int):
+            files = state['files']
+            if not files:
+                status.value = 'single-image mode — nothing to step'
+                return
+            state['cursor'] = int(np.clip(state['cursor'] + delta, 0, len(files) - 1))
+            load_slice(files[state['cursor']])
+
+        pan_w = CheckBox(label='Pan (left-drag moves slice)', value=False)
+        pan_w.changed.connect(lambda *_: setattr(viewer.camera, 'mouse_pan', pan_w.value)
+                              if not state['verify'] else None)
+        verify_w = CheckBox(label='Verify (warped + atlas)', value=False)
+        channel_w = ComboBox(label='channel', choices=['merge', 'R', 'G', 'B'], value='merge')
+        channel_w.changed.connect(lambda *_: display_raw()
+                                  if state['name'] is not None and not state['verify'] else None)
+
+        def on_verify(*_):
+            state['verify'] = verify_w.value
+            if state['name'] is not None:
+                display_slice()
+                viewer.reset_view()
+
+        verify_w.changed.connect(on_verify)
+
+        prev_btn = PushButton(text='◀ Prev slice')
+        prev_btn.changed.connect(lambda *_: step(-1))
+        next_btn = PushButton(text='Next slice ▶')
+        next_btn.changed.connect(lambda *_: step(+1))
+        undo_btn = PushButton(text='Undo last ROI')
+        undo_btn.changed.connect(lambda *_: remove_last())
+
+        def on_load_csv():
+            from qtpy.QtWidgets import QFileDialog
+            path, _ = QFileDialog.getOpenFileName(caption='Load raw-ROI CSV',
+                                                  filter='CSV (*.csv);;All files (*)')
+            if path:
+                load_csv_points(Path(path))
+
+        load_btn = PushButton(text='Load CSV')
+        load_btn.changed.connect(lambda *_: on_load_csv())
+        save_btn = PushButton(text='Save CSV')
+        save_btn.changed.connect(lambda *_: save_csv())
+        project_btn = PushButton(text='Project + Render (needs registration)')
+        project_btn.changed.connect(lambda *_: on_project())
+
+        panel = Container(widgets=[
+            self.header('Slice'), slice_lbl, self.srow(prev_btn, next_btn), verify_w,
+            self.header('ROIs'), summary, undo_btn, pan_w, channel_w, color_w,
+            self.header('Regions'), *regions.widgets,
+            self.header('Render'), self.srow(style_w, hemisphere_w), camera_w, no_root_w, project_btn,
+            self.header('CSV'), self.srow(load_btn, save_btn),
+            status_label,
+        ])
+        self.add_scroll_dock(viewer, panel, 'roi')
+
+        if state['files']:
+            load_slice(state['files'][0])
+        elif self.raw_image:
+            load_slice(self.raw_image)
+        if self._out.exists():
+            load_csv_points(self._out)  # auto-resume the session csv
+        refresh_summary()
+
+        printf('roi: click cells on raw slices, Save, then Project + Render after registering')
+        napari.run()
+
+
+if __name__ == '__main__':
+    RoiOptions().main()

regrender-0.1.0.dist-info/METADATA

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: regrender
+Version: 0.1.0
+Summary: 2D mouse brain registration, ROI/Probe annotation, and brainrender reconstruction
+Project-URL: Homepage, https://github.com/ytsimon2004/regrender
+Project-URL: Repository, https://github.com/ytsimon2004/regrender
+Project-URL: Documentation, https://regrender.readthedocs.io
+Author-email: Yu-Ting Wei <ytsimon2004@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: allen-ccf,brain-atlas,brainrender,napari,neuroscience,registration
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.12
+Requires-Dist: argclz>=1.0.1
+Requires-Dist: imageio
+Requires-Dist: napari[pyqt5]
+Requires-Dist: neuralib-atlas[brainrender]>=0.7.3
+Requires-Dist: rich
+Provides-Extra: doc
+Requires-Dist: pydata-sphinx-theme; extra == 'doc'
+Requires-Dist: sphinx; extra == 'doc'
+Requires-Dist: sphinx-copybutton; extra == 'doc'
+Provides-Extra: lint
+Requires-Dist: mypy; extra == 'lint'
+Requires-Dist: ruff; extra == 'lint'
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Description-Content-Type: text/markdown
+
+# regrender
+
+**Tools for 2D mouse brain registration to the Allen Common Coordinate Framework (CCF)**
+
+A napari-based Python toolkit
+For registering histological brain slices to the Allen Brain Atlas, annotating cells/ROIs,
+reconstructing probe tracks, and rendering the results with brainrender.
+
+## Features
+
+- **Interactive slice→CCF registration** (`regrender register`) — pick landmark pairs in napari, estimate a homography/affine transform.
+- **ROI annotation** (`regrender roi`) — label cells on raw images, project them into CCF space, and render.
+- **Probe-track reconstruction** (`regrender probe`) — reconstruct electrode shanks from dye labels across serial sections.
+- **brainrender rendering** of ROIs and probes in 3D atlas space.
+
+## Demo
+
+**`regrender register`** — match landmark pairs between the atlas plane (left) and histology (right):
+
+<img src="docs/source/_static/register.png" alt="register" width="800">
+
+**`regrender roi`** — label cells per channel, then project + render in 3D with brainrender:
+
+<img src="docs/source/_static/roi.png" alt="roi" width="800">
+
+**`regrender probe`** — pick dye points per shank and reconstruct the tracks in 3D:
+
+<img src="docs/source/_static/probe.png" alt="probe" width="800">
+
+
+## Installation
+
+```bash
+# Option 1 — one-shot CLI install, no clone or env needed (recommended for users)
+uv tool install git+https://github.com/ytsimon2004/regrender.git
+
+# Option 2 — uv virtual environment (development)
+git clone https://github.com/ytsimon2004/regrender.git && cd regrender
+uv venv && source .venv/bin/activate
+uv pip install -e .
+
+# Option 3 — conda environment (development)
+git clone https://github.com/ytsimon2004/regrender.git && cd regrender
+conda create -n regrender python=3.12 -y && conda activate regrender
+pip install -e .
+```
+
+See the [installation docs](https://regrender.readthedocs.io/en/latest/get_start/installation.html) for details.
+
+## Quick Start
+
+```bash
+# 1. label ROIs on raw slices
+regrender roi -D <slices_dir>
+
+# 2. register each slice to the CCF
+regrender register -D <slices_dir>
+
+# 3. project ROIs to CCF + render  (or use the GUI "Project + Render" button)
+regrender roi --project --render -D <slices_dir>
+
+# probe tracks
+regrender probe -D <slices_dir>
+```
+
+See the [full documentation](https://regrender.readthedocs.io) for the complete workflow.
+
+## Contact
+
+**Yu-Ting Wei** - ytsimon2004@gmail.com

regrender-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+regrender/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+regrender/__main__.py,sha256=W3RzXVBLBAErpoqxVrq-gW8owVLo4yLJHCZaW9FFyZc,1123
+regrender/_app.py,sha256=eSXp6PlihoIOz83Dg6YKr82aRmT0XUy9rkIaTmDdJqk,13541
+regrender/_core.py,sha256=sQV-F1KJH2uEGTI0pvFxdwOIzJmxD1DFS37We8Ai-Ss,12899
+regrender/main_probe.py,sha256=OA63ky4d1cTcbp8eIzIl0B4143bMAec1VB2_2pNhbE8,36739
+regrender/main_register.py,sha256=Wccxr7FFuUM8TyVhPLcea0TcvpAyzus0ZKRzT1pZLH8,30445
+regrender/main_roi.py,sha256=xF0FXXE-AKHHYtSa4bewn6uPAkuaOJMp51qP9fWe4XE,25280
+regrender-0.1.0.dist-info/METADATA,sha256=4M0U49kOR5a8ToJfYDL3hU6MSLku6zOtEhHESaoFWmg,3664
+regrender-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+regrender-0.1.0.dist-info/entry_points.txt,sha256=wrYgF2udJeJvNTZNQTDNIKcqbYc_z6Mu74Kg1V6LesY,54
+regrender-0.1.0.dist-info/licenses/LICENSE,sha256=4AWjAYxYbLp6AiBbzf4F3hPDwHBZvvu0z61Q8yMlEF0,1068
+regrender-0.1.0.dist-info/RECORD,,

regrender-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

regrender-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+regrender = regrender.__main__:main

regrender-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yu-Ting Wei
+
+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.