saline-dbs 0.3.0__tar.gz

saline_dbs-0.3.0/LICENSE

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

saline_dbs-0.3.0/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: saline-dbs
+Version: 0.3.0
+Summary: SALINE: filter-based localization and segmentation of DBS electrodes in clinical MRI
+Author: Vanessa H. Yu, Edward Chen, Jürgen Germann, Alexandre Boutet, Andres M. Lozano, Kâmil Uludağ, Sriranga Kashyap
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/srikash/SALINE
+Project-URL: Repository, https://github.com/srikash/SALINE
+Project-URL: Issues, https://github.com/srikash/SALINE/issues
+Project-URL: Paper, https://doi.org/10.1109/ISBI61048.2026.11515562
+Keywords: deep brain stimulation,dbs,electrode segmentation,mri,neuroimaging
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: nibabel
+Requires-Dist: scipy
+Requires-Dist: scikit-image
+Requires-Dist: scikit-learn
+Requires-Dist: click
+Requires-Dist: rich
+Requires-Dist: tqdm
+Dynamic: license-file
+
+# SALINE (part of DBS-ElecNet)
+## <b><ins>S</ins></b>egmentation <b><ins>A</ins></b>lgorithm using <b><ins>LIN</ins></b>e-fitting for <b><ins>E</ins></b>lectrodes
+
+*V. H. Yu et al., "DBS-ElecNet: Automated Localization and Segmentation of DBS Electrodes in Clinical MRI," 2026 IEEE 23rd International Symposium on Biomedical Imaging (ISBI), London, United Kingdom, 2026, pp. 1-4, doi:[10.1109/ISBI61048.2026.11515562](https://doi.org/10.1109/ISBI61048.2026.11515562)*
+
+Give SALINE a raw clinical T1-weighted MR image and it handles the rest: resampling, 
+skull-stripping (SynthStrip), bias correction (N4), and segmentation (SynthSeg) 
+all run via Docker, with no other install needed. It runs as a fully standalone CLI tool.
+
+It is the core of [DBS-ElecNet](https://github.com/BRAIN-TO/DBS-ElecNet)'s 
+classical (non-deep-learning) segmentation pipeline.
+
+## Why SALINE?
+
+SALINE is a classical, filtering-based automatic segmentation method for DBS
+electrodes: no training, no manual annotation, no GPU. Give it an MRI, a brain
+mask, and a SynthSeg segmentation, and it finds the electrode track with a
+Laplacian/Frangi filter cascade and a line fit.
+
+That makes it well suited to building a large database of electrode
+segmentations, at scale, without a human labeling each scan by hand. In the
+DBS-ElecNet paper, SALINE segmented 280 post-operative MRI scans in about 1.5
+minutes each, and those segmentations became the training data for
+DBS-ElecNet's 3D U-Net. Any similar segmentation model can be trained the
+same way: run SALINE over a cohort, use its output as ground truth.
+
+## Install
+
+Requires Python 3.12+ and [Docker](https://www.docker.com) (recommended; see
+below for running without it).
+
+```bash
+pip install git+https://github.com/srikash/SALINE.git@v0.3.0
+```
+
+## Usage
+
+Dual-electrode (default, also available explicitly as `saline dual`):
+
+```bash
+saline --input subject.nii.gz
+```
+
+Single-electrode:
+
+```bash
+saline single --input subject.nii.gz
+```
+
+`--input` is a raw, native-space clinical MRI. SALINE resamples it to 1mm
+isotropic, skull-strips it (SynthStrip), bias-corrects it (N4), and segments
+it (SynthSeg) before finding the electrode track. All of this runs via
+Docker, pulling [`antsx/ants`](https://hub.docker.com/r/antsx/ants),
+[`freesurfer/synthstrip`](https://hub.docker.com/r/freesurfer/synthstrip), and
+[`cookpa/synthseg`](https://hub.docker.com/r/cookpa/synthseg) on first use.
+
+**Output:**
+
+* `subject_saline_elecSeg.nii.gz`: the electrode segmentation, in `--input`'s native space.
+* `subject_1mm_iso.nii.gz`: the resampled MRI, kept for reference.
+* `subject_1mm_iso_saline_elecSeg.nii.gz`: the electrode segmentation, in 1mm-isotropic space.
+
+**Running without Docker:**
+
+If Docker isn't available, pass precomputed files instead. Both must already
+be in the same 1mm-isotropic space as `subject_1mm_iso.nii.gz`:
+
+* `--brain_mask PATH`: skips Docker-based SynthStrip.
+* `--synthseg PATH`: skips Docker-based SynthSeg.
+
+ANTs (resampling, N4, mask multiply) falls back to a local install
+(`ResampleImage`, `N4BiasFieldCorrection`, `ImageMath` on `PATH`) if Docker
+isn't available. There's no equivalent precomputed-file option for those.
+
+**Optional arguments:**
+
+* `--threads` (default `5`): threads for SynthSeg.
+* `--laplacian_threshold` (default `0.21`)
+* `--frangi_threshold` (default `0.25`)
+* `--lower_frangi_threshold` (default `0.2`): used if the higher threshold finds no candidates.
+* `--expand_radius` (default `6`): dilation radius applied to the final line mask.
+* `--save_intermediate`: also save the thresholded Laplacian, Frangi, and combined masks.
+
+## Citation
+
+If you use this in your work, please cite the paper above (see [`CITATION.cff`](CITATION.cff)
+for the full machine-readable record).
+
+## Releasing
+
+Publishing a GitHub Release triggers `.github/workflows/release.yml`, which
+builds the package and publishes it to PyPI via
+[trusted publishing](https://docs.pypi.org/trusted-publishers/) (no API token
+stored in the repo). One-time setup on PyPI, before the first release:
+add a trusted publisher on the `saline-dbs` project (or as a pending
+publisher if the project doesn't exist yet) pointing at this repository,
+workflow `release.yml`, environment `pypi`.

saline_dbs-0.3.0/README.md

@@ -0,0 +1,97 @@
+# SALINE (part of DBS-ElecNet)
+## <b><ins>S</ins></b>egmentation <b><ins>A</ins></b>lgorithm using <b><ins>LIN</ins></b>e-fitting for <b><ins>E</ins></b>lectrodes
+
+*V. H. Yu et al., "DBS-ElecNet: Automated Localization and Segmentation of DBS Electrodes in Clinical MRI," 2026 IEEE 23rd International Symposium on Biomedical Imaging (ISBI), London, United Kingdom, 2026, pp. 1-4, doi:[10.1109/ISBI61048.2026.11515562](https://doi.org/10.1109/ISBI61048.2026.11515562)*
+
+Give SALINE a raw clinical T1-weighted MR image and it handles the rest: resampling, 
+skull-stripping (SynthStrip), bias correction (N4), and segmentation (SynthSeg) 
+all run via Docker, with no other install needed. It runs as a fully standalone CLI tool.
+
+It is the core of [DBS-ElecNet](https://github.com/BRAIN-TO/DBS-ElecNet)'s 
+classical (non-deep-learning) segmentation pipeline.
+
+## Why SALINE?
+
+SALINE is a classical, filtering-based automatic segmentation method for DBS
+electrodes: no training, no manual annotation, no GPU. Give it an MRI, a brain
+mask, and a SynthSeg segmentation, and it finds the electrode track with a
+Laplacian/Frangi filter cascade and a line fit.
+
+That makes it well suited to building a large database of electrode
+segmentations, at scale, without a human labeling each scan by hand. In the
+DBS-ElecNet paper, SALINE segmented 280 post-operative MRI scans in about 1.5
+minutes each, and those segmentations became the training data for
+DBS-ElecNet's 3D U-Net. Any similar segmentation model can be trained the
+same way: run SALINE over a cohort, use its output as ground truth.
+
+## Install
+
+Requires Python 3.12+ and [Docker](https://www.docker.com) (recommended; see
+below for running without it).
+
+```bash
+pip install git+https://github.com/srikash/SALINE.git@v0.3.0
+```
+
+## Usage
+
+Dual-electrode (default, also available explicitly as `saline dual`):
+
+```bash
+saline --input subject.nii.gz
+```
+
+Single-electrode:
+
+```bash
+saline single --input subject.nii.gz
+```
+
+`--input` is a raw, native-space clinical MRI. SALINE resamples it to 1mm
+isotropic, skull-strips it (SynthStrip), bias-corrects it (N4), and segments
+it (SynthSeg) before finding the electrode track. All of this runs via
+Docker, pulling [`antsx/ants`](https://hub.docker.com/r/antsx/ants),
+[`freesurfer/synthstrip`](https://hub.docker.com/r/freesurfer/synthstrip), and
+[`cookpa/synthseg`](https://hub.docker.com/r/cookpa/synthseg) on first use.
+
+**Output:**
+
+* `subject_saline_elecSeg.nii.gz`: the electrode segmentation, in `--input`'s native space.
+* `subject_1mm_iso.nii.gz`: the resampled MRI, kept for reference.
+* `subject_1mm_iso_saline_elecSeg.nii.gz`: the electrode segmentation, in 1mm-isotropic space.
+
+**Running without Docker:**
+
+If Docker isn't available, pass precomputed files instead. Both must already
+be in the same 1mm-isotropic space as `subject_1mm_iso.nii.gz`:
+
+* `--brain_mask PATH`: skips Docker-based SynthStrip.
+* `--synthseg PATH`: skips Docker-based SynthSeg.
+
+ANTs (resampling, N4, mask multiply) falls back to a local install
+(`ResampleImage`, `N4BiasFieldCorrection`, `ImageMath` on `PATH`) if Docker
+isn't available. There's no equivalent precomputed-file option for those.
+
+**Optional arguments:**
+
+* `--threads` (default `5`): threads for SynthSeg.
+* `--laplacian_threshold` (default `0.21`)
+* `--frangi_threshold` (default `0.25`)
+* `--lower_frangi_threshold` (default `0.2`): used if the higher threshold finds no candidates.
+* `--expand_radius` (default `6`): dilation radius applied to the final line mask.
+* `--save_intermediate`: also save the thresholded Laplacian, Frangi, and combined masks.
+
+## Citation
+
+If you use this in your work, please cite the paper above (see [`CITATION.cff`](CITATION.cff)
+for the full machine-readable record).
+
+## Releasing
+
+Publishing a GitHub Release triggers `.github/workflows/release.yml`, which
+builds the package and publishes it to PyPI via
+[trusted publishing](https://docs.pypi.org/trusted-publishers/) (no API token
+stored in the repo). One-time setup on PyPI, before the first release:
+add a trusted publisher on the `saline-dbs` project (or as a pending
+publisher if the project doesn't exist yet) pointing at this repository,
+workflow `release.yml`, environment `pypi`.

saline_dbs-0.3.0/pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "saline-dbs"
+version = "0.3.0"
+description = "SALINE: filter-based localization and segmentation of DBS electrodes in clinical MRI"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+authors = [
+    { name = "Vanessa H. Yu" },
+    { name = "Edward Chen" },
+    { name = "Jürgen Germann" },
+    { name = "Alexandre Boutet" },
+    { name = "Andres M. Lozano" },
+    { name = "Kâmil Uludağ" },
+    { name = "Sriranga Kashyap" },
+]
+keywords = [
+    "deep brain stimulation",
+    "dbs",
+    "electrode segmentation",
+    "mri",
+    "neuroimaging",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Image Processing",
+    "Topic :: Scientific/Engineering :: Medical Science Apps.",
+]
+dependencies = [
+    "numpy",
+    "nibabel",
+    "scipy",
+    "scikit-image",
+    "scikit-learn",
+    "click",
+    "rich",
+    "tqdm",
+]
+
+[project.urls]
+Homepage = "https://github.com/srikash/SALINE"
+Repository = "https://github.com/srikash/SALINE"
+Issues = "https://github.com/srikash/SALINE/issues"
+Paper = "https://doi.org/10.1109/ISBI61048.2026.11515562"
+
+[project.scripts]
+saline = "saline.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["saline*"]

saline_dbs-0.3.0/saline/__init__.py

@@ -0,0 +1,3 @@
+from .segment import segment
+
+__all__ = ["segment"]

saline_dbs-0.3.0/saline/cli.py

@@ -0,0 +1,151 @@
+import os
+
+import click
+import nibabel as nib
+from rich.console import Console
+from tqdm import tqdm
+
+from . import external
+from .pipeline import preprocess
+from .segment import segment
+
+console = Console()
+
+CITATION = (
+    'V. H. Yu et al., "DBS-ElecNet: Automated Localization and Segmentation of DBS '
+    'Electrodes in Clinical MRI," 2026 IEEE 23rd International Symposium on Biomedical '
+    'Imaging (ISBI), London, United Kingdom, 2026, pp. 1-4, '
+    'doi:10.1109/ISBI61048.2026.11515562'
+)
+CITATION_NOTICE = f"If you use this in your work, please cite {CITATION}"
+
+
+class DefaultGroup(click.Group):
+    """A click.Group where an unrecognized/absent subcommand falls back to one
+    named command, so `saline --input ...` still means `saline dual --input ...`
+    without `dual`'s options leaking onto the group itself (which would make
+    them required even when running `saline single ...`).
+
+    Click's own option parsing for the group runs before `resolve_command` is
+    ever reached, so the default has to be injected in `parse_args`, before
+    Click tries (and fails) to interpret `--input` as a group-level option."""
+
+    def __init__(self, *args, default_command=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.default_command = default_command
+
+    def parse_args(self, ctx, args):
+        if args and args[0] not in ('-h', '--help') and (
+            args[0].startswith('-') or args[0] not in self.commands
+        ):
+            args = [self.default_command, *args]
+        return super().parse_args(ctx, args)
+
+
+def _common_options(f):
+    f = click.option('--input', 'input_path', required=True, type=str,
+                      help='path to the raw, native-space input MRI')(f)
+    f = click.option('--brain_mask', 'brain_mask_override', type=str, default=None,
+                      help='precomputed brain mask (1mm-isotropic space); skips Docker-based SynthStrip')(f)
+    f = click.option('--synthseg', 'synthseg_override', type=str, default=None,
+                      help='precomputed SynthSeg segmentation (1mm-isotropic space); skips Docker-based SynthSeg')(f)
+    f = click.option('--threads', type=int, default=5, show_default=True,
+                      help='threads for SynthSeg')(f)
+    f = click.option('--laplacian_threshold', type=float, default=0.21, show_default=True, help='the threshold value for laplacian filtered image')(f)
+    f = click.option('--frangi_threshold', type=float, default=0.25, show_default=True, help='the threshold value for frangi filtered image')(f)
+    f = click.option('--lower_frangi_threshold', type=float, default=0.2, show_default=True, help='the threshold value for frangi filtered image if the higher one failed')(f)
+    f = click.option('--expand_radius', type=int, default=6, show_default=True, help='the radius of the final dilation')(f)
+    f = click.option('--save_intermediate', is_flag=True, help='save intermediate images (thresholded laplacian and frangi images; combined image) if specified')(f)
+    return f
+
+
+def _run(num_regions, input_path, brain_mask_override, synthseg_override, threads,
+          laplacian_threshold, frangi_threshold, lower_frangi_threshold,
+          expand_radius, save_intermediate):
+    nname = os.path.basename(input_path).split('.nii')[0]
+    console.print(f"[bold]SALINE[/bold] start — [cyan]{nname}[/cyan]")
+
+    with tqdm(desc="SALINE", unit="stage", leave=False) as bar:
+        def on_stage(message):
+            bar.set_description(message)
+            bar.update(1)
+
+        try:
+            paths = preprocess(
+                input_path, brain_mask_override=brain_mask_override,
+                synthseg_override=synthseg_override, threads=threads, on_stage=on_stage,
+            )
+        except external.ExternalToolError as e:
+            console.print(f"[red]✗[/red] {e}")
+            raise SystemExit(1)
+
+        img = nib.load(paths["n4"])
+        br_mask_data = nib.load(paths["brain_mask"]).get_fdata()
+        seg_data = nib.load(paths["synthseg"]).get_fdata()
+
+        result = segment(
+            img.get_fdata(), br_mask_data, seg_data, num_regions,
+            laplacian_threshold, frangi_threshold, lower_frangi_threshold,
+            expand_radius=expand_radius,
+            save_intermediate=lambda name, array: (
+                nib.save(nib.Nifti1Image(array.astype('uint8'), img.affine, img.header),
+                          f"{paths['base']}_{name}.nii.gz")
+                if save_intermediate else None
+            ),
+            on_stage=on_stage,
+        )
+
+        for intermediate in ("stripped", "brain_mask", "n4", "synthseg"):
+            try:
+                os.remove(paths[intermediate])
+            except FileNotFoundError:
+                pass
+
+        if result is None:
+            console.print(f"[red]✗[/red] no candidates found for [cyan]{nname}[/cyan], skipping")
+            console.print(f"\n[dim]{CITATION_NOTICE}[/dim]")
+            return
+
+        on_stage("Resampling result back to native space")
+        iso_result_path = f"{paths['base']}_1mm_iso_saline_elecSeg.nii.gz"
+        nib.save(nib.Nifti1Image(result, img.affine, img.header), iso_result_path)
+        native_result_path = f"{paths['base']}_saline_elecSeg.nii.gz"
+        external.resample_to_native(iso_result_path, native_result_path, paths["native_shape"])
+
+    console.print(f"[green]✓ SALINE done[/green] — [cyan]{nname}[/cyan]")
+    console.print(f"\n[dim]{CITATION_NOTICE}[/dim]")
+
+
+@click.group(cls=DefaultGroup, default_command='dual', epilog=CITATION_NOTICE)
+def cli():
+    """Segmenting the electrode(s) with SALINE."""
+
+
+@cli.command(epilog=CITATION_NOTICE)
+@_common_options
+def dual(input_path, brain_mask_override, synthseg_override, threads,
+          laplacian_threshold, frangi_threshold, lower_frangi_threshold,
+          expand_radius, save_intermediate):
+    """Dual-electrode mode (left/right split). This is the default."""
+    _run(2, input_path, brain_mask_override, synthseg_override, threads,
+         laplacian_threshold, frangi_threshold, lower_frangi_threshold,
+         expand_radius, save_intermediate)
+
+
+@cli.command(epilog=CITATION_NOTICE)
+@_common_options
+def single(input_path, brain_mask_override, synthseg_override, threads,
+            laplacian_threshold, frangi_threshold, lower_frangi_threshold,
+            expand_radius, save_intermediate):
+    """Single-electrode mode."""
+    _run(1, input_path, brain_mask_override, synthseg_override, threads,
+         laplacian_threshold, frangi_threshold, lower_frangi_threshold,
+         expand_radius, save_intermediate)
+
+
+def main():
+    cli()
+
+
+if __name__ == "__main__":
+    main()

saline_dbs-0.3.0/saline/detect.py

@@ -0,0 +1,52 @@
+import numpy as np
+from scipy.ndimage import laplace
+from skimage.filters import frangi
+from skimage import morphology
+
+
+def detect_candidates(image, br_mask, csf, laplacian_threshold, frangi_threshold):
+    """
+    Detect electrode-track candidate voxels in `image` by combining a Laplacian-based
+    edge mask and a Frangi vesselness mask, both restricted to `csf` and `br_mask`.
+
+    Shared by both single- and dual-electrode segmentation: this step never differed
+    between the two modes, only the line-fitting that follows it did.
+
+    Returns (combined, lap, normalized_frangi):
+      combined: the main candidate mask (frangi_img & lap).
+      lap: the thresholded Laplacian mask alone, used by the laplacian-only fallback.
+      normalized_frangi: the normalized Frangi response, re-thresholded by callers
+        at a lower threshold if `combined` turns out too small.
+    """
+    brain_mask = morphology.isotropic_erosion(br_mask, radius=20)
+    laplacian_filtered = laplace(image)
+    pos = np.where(laplacian_filtered > 0, laplacian_filtered, 0)
+    neg = -np.where(laplacian_filtered < 0, laplacian_filtered, 0)
+    normalized_pos = pos / np.max(pos)
+    normalized_neg = neg / np.max(neg)
+
+    thresholded_pos = normalized_pos > laplacian_threshold
+    thresholded_neg = normalized_neg > laplacian_threshold
+    thresholded_img = thresholded_pos | thresholded_neg
+    thresholded_img = thresholded_img.astype(np.uint8) * brain_mask.astype(np.uint8)
+    thresholded_img = morphology.isotropic_closing(thresholded_img, radius=3)
+    thresholded_img = morphology.remove_small_objects(thresholded_img, max_size=4)
+    thresholded_img = morphology.isotropic_dilation(thresholded_img, radius=2)
+    lap = thresholded_img * csf
+
+    brain_mask = morphology.isotropic_erosion(br_mask, radius=2)
+    filtered = frangi(image)
+    filtered = filtered * brain_mask.astype(np.uint8)
+    min_val = np.min(filtered)
+    max_val = np.max(filtered)
+    normalized_frangi = (filtered - min_val) / (max_val - min_val)
+
+    thresholded_image = normalized_frangi > frangi_threshold
+    thresholded_image = morphology.isotropic_closing(thresholded_image, radius=3)
+    thresholded_image = morphology.remove_small_objects(thresholded_image, max_size=4)
+    thresholded_image = morphology.isotropic_closing(thresholded_image, radius=8)
+    thresholded_image = morphology.isotropic_dilation(thresholded_image, radius=2)
+    frangi_img = thresholded_image * csf
+
+    combined = frangi_img & lap
+    return combined, lap, normalized_frangi

saline_dbs-0.3.0/saline/external.py

@@ -0,0 +1,165 @@
+"""Runs the external tools SALINE's standalone pipeline needs: ANTs
+(resampling, N4 bias correction, mask multiply), SynthStrip, and SynthSeg.
+
+Docker is tried first for all three, since it needs no local install:
+  - ANTs:       https://hub.docker.com/r/antsx/ants
+  - SynthStrip: https://hub.docker.com/r/freesurfer/synthstrip
+  - SynthSeg:   https://hub.docker.com/r/cookpa/synthseg
+
+ANTs falls back to a local install (`ResampleImage`/`N4BiasFieldCorrection`/
+`ImageMath` on PATH) if Docker isn't available, since there's no other
+precomputed file a caller could hand in for a resampling step. SynthStrip
+and SynthSeg have no such local fallback here -- if Docker isn't available,
+the caller (pipeline.preprocess) expects a precomputed brain mask or
+segmentation instead.
+
+Every path handed to a container is resolved to an absolute path first: the
+container's working directory is not the caller's cwd, so a relative path
+like `saline --input subject.nii.gz` would otherwise mount the right
+directory but still fail to find the file by its relative name inside it.
+"""
+
+import os
+import shutil
+import subprocess
+
+ANTS_DOCKER_IMAGE = os.environ.get("SALINE_ANTS_IMAGE", "antsx/ants:latest")
+SYNTHSTRIP_DOCKER_IMAGE = os.environ.get("SALINE_SYNTHSTRIP_IMAGE", "freesurfer/synthstrip:1.8")
+SYNTHSEG_DOCKER_IMAGE = os.environ.get("SALINE_SYNTHSEG_IMAGE", "cookpa/synthseg:conda-0.2")
+
+
+class ExternalToolError(RuntimeError):
+    pass
+
+
+def docker_available():
+    if shutil.which("docker") is None:
+        return False
+    try:
+        subprocess.run(
+            ["docker", "info"],
+            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+            timeout=10, check=True,
+        )
+        return True
+    except (subprocess.SubprocessError, OSError):
+        return False
+
+
+def _run(cmd):
+    result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+    if result.returncode != 0:
+        raise ExternalToolError(
+            f"command failed ({result.returncode}): {' '.join(cmd)}\n{result.stdout}"
+        )
+
+
+def _run_in_docker(image, args):
+    """`args` must already be absolute paths (see module docstring) mixed with
+    plain string flags/values; only `str` entries that are existing parent
+    directories matter for mounting, so callers pass the full arg list and we
+    mount every absolute path's parent directory found in it."""
+    dirs = sorted({os.path.dirname(a) for a in args if a.startswith("/")})
+    mounts = []
+    for d in dirs:
+        mounts += ["-v", f"{d}:{d}"]
+    cmd = [
+        "docker", "run", "--rm",
+        "-u", f"{os.getuid()}:{os.getgid()}",
+        *mounts, image, *args,
+    ]
+    _run(cmd)
+
+
+def resample_to_iso(input_path, output_path, spacing="1.0x1.0x1.0"):
+    """Resample `input_path` to isotropic `spacing` mm, windowed-sinc (Lanczos)
+    interpolated -- suitable for a continuous-intensity MRI, not a label mask."""
+    input_path = os.path.realpath(input_path)
+    output_path = os.path.realpath(output_path)
+    args = ["ResampleImage", "3", input_path, output_path, spacing, "0", "3[l]"]
+    if docker_available():
+        _run_in_docker(ANTS_DOCKER_IMAGE, args)
+    elif shutil.which("ResampleImage"):
+        _run(args)
+    else:
+        raise ExternalToolError(
+            "Neither Docker nor a local ResampleImage (ANTs) was found. "
+            "Install Docker, or install ANTs locally."
+        )
+
+
+def resample_to_native(input_path, output_path, native_shape):
+    """Resample a label/mask volume at `input_path` to `native_shape`
+    (a (d1, d2, d3) voxel-count tuple), nearest-neighbor interpolated so
+    binary values aren't blurred."""
+    input_path = os.path.realpath(input_path)
+    output_path = os.path.realpath(output_path)
+    size = "x".join(str(int(d)) for d in native_shape)
+    args = ["ResampleImage", "3", input_path, output_path, size, "1", "1"]
+    if docker_available():
+        _run_in_docker(ANTS_DOCKER_IMAGE, args)
+    elif shutil.which("ResampleImage"):
+        _run(args)
+    else:
+        raise ExternalToolError(
+            "Neither Docker nor a local ResampleImage (ANTs) was found. "
+            "Install Docker, or install ANTs locally."
+        )
+
+
+def n4_correct(input_path, mask_path, output_path):
+    input_path = os.path.realpath(input_path)
+    mask_path = os.path.realpath(mask_path)
+    output_path = os.path.realpath(output_path)
+    args = ["N4BiasFieldCorrection", "-d", "3", "-x", mask_path, "-i", input_path, "-o", output_path]
+    if docker_available():
+        _run_in_docker(ANTS_DOCKER_IMAGE, args)
+    elif shutil.which("N4BiasFieldCorrection"):
+        _run(args)
+    else:
+        raise ExternalToolError(
+            "Neither Docker nor a local N4BiasFieldCorrection (ANTs) was found. "
+            "Install Docker, or install ANTs locally."
+        )
+
+
+def mask_multiply(output_path, image_path, mask_path):
+    """output = image * mask, i.e. a skull-stripped image given a brain mask."""
+    output_path = os.path.realpath(output_path)
+    image_path = os.path.realpath(image_path)
+    mask_path = os.path.realpath(mask_path)
+    args = ["ImageMath", "3", output_path, "m", image_path, mask_path]
+    if docker_available():
+        _run_in_docker(ANTS_DOCKER_IMAGE, args)
+    elif shutil.which("ImageMath"):
+        _run(args)
+    else:
+        raise ExternalToolError(
+            "Neither Docker nor a local ImageMath (ANTs) was found. "
+            "Install Docker, or install ANTs locally."
+        )
+
+
+def synthstrip(input_path, stripped_out, mask_out):
+    if not docker_available():
+        raise ExternalToolError(
+            "Docker isn't available to run SynthStrip. "
+            "Install Docker, or pass a precomputed brain mask instead."
+        )
+    input_path = os.path.realpath(input_path)
+    stripped_out = os.path.realpath(stripped_out)
+    mask_out = os.path.realpath(mask_out)
+    args = ["-i", input_path, "-o", stripped_out, "-m", mask_out]
+    _run_in_docker(SYNTHSTRIP_DOCKER_IMAGE, args)
+
+
+def synthseg(input_path, seg_out, threads=5):
+    if not docker_available():
+        raise ExternalToolError(
+            "Docker isn't available to run SynthSeg. "
+            "Install Docker, or pass a precomputed segmentation instead."
+        )
+    input_path = os.path.realpath(input_path)
+    seg_out = os.path.realpath(seg_out)
+    args = ["--i", input_path, "--o", seg_out, "--threads", str(threads), "--cpu"]
+    _run_in_docker(SYNTHSEG_DOCKER_IMAGE, args)

saline_dbs-0.3.0/saline/fit.py

@@ -0,0 +1,62 @@
+import numpy as np
+from skimage import morphology
+from sklearn.linear_model import RANSACRegressor
+
+
+def fit_best_fit_line_RANSAC(points):
+    X = points[:, :2]  # Use the first two coordinates (x, y) as features
+    y = points[:, 2]   # Use the third coordinate (z) as the target
+
+    ransac = RANSACRegressor(min_samples=2, random_state=42, loss='absolute_error')
+    ransac.fit(X, y)
+
+    inlier_points = points[ransac.inlier_mask_]
+    centroid = np.mean(inlier_points, axis=0)
+    centered_points = inlier_points - centroid
+    _, _, vt = np.linalg.svd(centered_points)
+    direction = vt[0]
+
+    return centroid, direction
+
+
+def fit_best_fit_line(points):
+    centroid = np.mean(points, axis=0)
+    centered_points = points - centroid
+    _, _, vt = np.linalg.svd(centered_points)
+    direction = vt[0]
+
+    return centroid, direction
+
+
+def draw_lines(ends, img_shape, fits, br_mask, radius=6):
+    """
+    Draw one dilated binary mask covering every region's fitted line.
+
+    Args:
+        ends: per-region starting slice index, same length as `fits` (length 1 for
+            single-electrode, length 2 for dual-electrode: left end, right end).
+        img_shape: shape of the 3D volume, used to keep points in bounds.
+        fits: per-region (centroid, direction) tuples, one per region.
+        br_mask: brain mask the result is multiplied by before dilation.
+        radius: dilation radius applied to the final mask.
+
+    Returns:
+        A binary mask with ones along every region's line, dilated by `radius`.
+    """
+    step = 0.1
+    final_result = np.zeros(img_shape)
+
+    for end, (centroid, direction) in zip(ends, fits):
+        z = np.arange(end, img_shape[-1], step)
+        # k is the scalar in the line definition equation (point = centroid + k * direction)
+        k = (z - centroid[-1]) / direction[-1]
+        elec = np.floor(centroid + np.outer(k, direction)).astype(int)
+
+        cond = (elec[:, 0] > 0) & (elec[:, 0] < img_shape[0]) & \
+               (elec[:, 1] > 0) & (elec[:, 1] < img_shape[1]) & \
+               (elec[:, 2] > 0) & (elec[:, 2] < img_shape[2])
+        final_result[tuple(elec[cond].T)] = 1
+
+    final_result = final_result * br_mask
+    final_result = morphology.isotropic_dilation(final_result, radius=radius)
+    return final_result

saline_dbs-0.3.0/saline/pipeline.py

@@ -0,0 +1,75 @@
+import os
+import shutil
+
+from . import external
+from .volume import get_shape
+
+
+def derive_base(input_path):
+    """Strip the .nii/.nii.gz suffix, e.g. '/a/b/subject.nii.gz' -> '/a/b/subject'."""
+    idx = input_path.find(".nii")
+    return input_path[:idx] if idx != -1 else input_path
+
+
+def _copy_if_distinct(src, dst):
+    """shutil.copy, but a no-op when src already *is* dst (e.g. the caller's
+    override file happens to sit at the pipeline's own derived path)."""
+    if os.path.realpath(src) != os.path.realpath(dst):
+        shutil.copy(src, dst)
+
+
+def preprocess(raw_input_path, brain_mask_override=None, synthseg_override=None,
+                threads=5, on_stage=None):
+    """
+    Run the full SALINE preprocessing pipeline on a raw, native-space clinical
+    MRI: resample to 1mm isotropic, skull-strip (SynthStrip), N4 bias correct,
+    segment (SynthSeg). SynthStrip and SynthSeg run via Docker by default; pass
+    `brain_mask_override` / `synthseg_override` (paths to precomputed files,
+    already in 1mm-isotropic space) to skip either step, e.g. when Docker isn't
+    available.
+
+    Returns a dict with the paths of every file produced (including the
+    retained 1mm-isotropic MRI) and `native_shape`, the original volume's
+    voxel shape, needed to resample results back to native space afterward.
+    """
+    on_stage = on_stage or (lambda message: None)
+    base = derive_base(raw_input_path)
+
+    native_shape = get_shape(raw_input_path)
+
+    iso_path = f"{base}_1mm_iso.nii.gz"
+    stripped_path = f"{base}_1mm_iso_skull_striped.nii.gz"
+    mask_path = f"{base}_1mm_iso_brain_mask.nii.gz"
+    n4_path = f"{base}_1mm_iso_skull_striped_n4.nii.gz"
+    seg_path = f"{base}_1mm_iso_skull_striped_n4_seg.nii.gz"
+
+    on_stage("Resampling to 1mm isotropic")
+    external.resample_to_iso(raw_input_path, iso_path)
+
+    if brain_mask_override:
+        on_stage("Using provided brain mask")
+        _copy_if_distinct(brain_mask_override, mask_path)
+        external.mask_multiply(stripped_path, iso_path, mask_path)
+    else:
+        on_stage("Running SynthStrip")
+        external.synthstrip(iso_path, stripped_path, mask_path)
+
+    on_stage("N4 bias correction")
+    external.n4_correct(stripped_path, mask_path, n4_path)
+
+    if synthseg_override:
+        on_stage("Using provided SynthSeg segmentation")
+        _copy_if_distinct(synthseg_override, seg_path)
+    else:
+        on_stage("Running SynthSeg")
+        external.synthseg(n4_path, seg_path, threads=threads)
+
+    return {
+        "base": base,
+        "native_shape": native_shape,
+        "iso": iso_path,
+        "stripped": stripped_path,
+        "brain_mask": mask_path,
+        "n4": n4_path,
+        "synthseg": seg_path,
+    }

saline_dbs-0.3.0/saline/segment.py

@@ -0,0 +1,122 @@
+import numpy as np
+from skimage import morphology
+
+from .detect import detect_candidates
+from .fit import fit_best_fit_line, fit_best_fit_line_RANSAC, draw_lines
+
+CSF_EXCLUDED_LABELS = (24, 4, 43, 44, 5, 15)  # SynthSeg labels for CSF / excluded structures
+VENTRAL_DC_LABELS = (28, 60)  # left, right VentralDC: electrode track ends near its base
+
+
+def _electrode_ends(seg, num_regions):
+    _, __, left_end = np.min(np.transpose(np.nonzero(seg == VENTRAL_DC_LABELS[0])), axis=0)
+    _, __, right_end = np.min(np.transpose(np.nonzero(seg == VENTRAL_DC_LABELS[1])), axis=0)
+    if num_regions == 1:
+        return (max(left_end, right_end) + 5,)
+    return (left_end + 5, right_end + 5)
+
+
+def _region_points(mask, num_regions):
+    """Split `mask` into left/right halves for dual-electrode mode, or take it whole."""
+    if num_regions == 1:
+        return [np.transpose(np.nonzero(mask))]
+    half = mask.shape[0] // 2
+    left = np.zeros_like(mask)
+    right = np.zeros_like(mask)
+    left[:half, :, :] = mask[:half, :, :]
+    right[half:, :, :] = mask[half:, :, :]
+    return [np.transpose(np.nonzero(left)), np.transpose(np.nonzero(right))]
+
+
+def _regions_have_spread(points_list, axis, min_spread):
+    if any(pts.shape[0] == 0 for pts in points_list):
+        return False
+    for pts in points_list:
+        spread = pts[:, axis].max() - pts[:, axis].min()
+        if spread < min_spread:
+            return False
+    return True
+
+
+def _fit_regions_with_ransac_check(points_list):
+    """Fallback-path fit: use RANSAC when points look like they contain outliers."""
+    fits = []
+    for pts in points_list:
+        y_spread = pts[:, 1].max() - pts[:, 1].min()
+        if y_spread > 30:
+            fits.append(fit_best_fit_line_RANSAC(pts))
+        else:
+            fits.append(fit_best_fit_line(pts))
+    return fits
+
+
+def segment(image, br_mask, seg, num_regions,
+            laplacian_threshold, frangi_threshold, lower_frangi_threshold,
+            expand_radius=6, save_intermediate=None, on_stage=None):
+    """
+    Segment one (num_regions=1) or two (num_regions=2, left/right split) electrode
+    tracks in `image`.
+
+    Args:
+        image, br_mask, seg: np.ndarray volumes — the subject MRI, its brain mask,
+            and its SynthSeg label volume.
+        num_regions: 1 for single-electrode mode, 2 for dual-electrode mode.
+        laplacian_threshold, frangi_threshold, lower_frangi_threshold: detection
+            thresholds (see `detect.detect_candidates`).
+        expand_radius: dilation radius (voxels) applied to the final line mask.
+        save_intermediate: optional `callback(name, mask)` invoked with each
+            intermediate mask that's worth persisting, so this function stays
+            array-in/array-out and callers decide whether/how to save to disk.
+        on_stage: optional `callback(message: str)` invoked as processing enters
+            each named stage, so callers can drive their own progress display
+            (e.g. a progress bar) without this function knowing it exists.
+
+    Returns:
+        A binary mask (np.ndarray) covering the detected electrode track(s), or
+        None if no candidate voxels could be found even after both fallbacks.
+    """
+    on_stage = on_stage or (lambda message: None)
+
+    on_stage("Computing CSF mask")
+    csf = np.ones(seg.shape, dtype=bool)
+    for label in CSF_EXCLUDED_LABELS:
+        csf &= (seg != label)
+    csf = morphology.isotropic_erosion(csf, radius=3)
+
+    ends = _electrode_ends(seg, num_regions)
+
+    on_stage("Detecting candidate voxels (Laplacian + Frangi)")
+    combined, lap, normalized_frangi = detect_candidates(
+        image, br_mask, csf, laplacian_threshold, frangi_threshold)
+
+    if save_intermediate:
+        save_intermediate("thr-lap", lap)
+        save_intermediate("comb", combined)
+
+    points = _region_points(combined, num_regions)
+
+    if _regions_have_spread(points, axis=2, min_spread=10):
+        on_stage("Fitting line(s)")
+        fits = [fit_best_fit_line(pts) for pts in points]
+    else:
+        on_stage("Lowering Frangi threshold")
+        frangi_img = normalized_frangi > lower_frangi_threshold
+        frangi_img = frangi_img * csf
+        frangi_img = morphology.isotropic_closing(frangi_img, radius=3)
+        frangi_img = morphology.remove_small_objects(frangi_img, max_size=4)
+        if save_intermediate:
+            save_intermediate("frangi", frangi_img)
+        points = _region_points(frangi_img, num_regions)
+
+        if any(pts.shape[0] == 0 for pts in points):
+            on_stage("Falling back to Laplacian-only mask")
+            points = _region_points(lap, num_regions)
+            if any(pts.shape[0] == 0 for pts in points):
+                on_stage("No candidate voxels found — skipping")
+                return None
+
+        on_stage("Fitting line(s) (fallback)")
+        fits = _fit_regions_with_ransac_check(points)
+
+    on_stage("Drawing segmentation mask")
+    return draw_lines(ends, image.shape, fits, br_mask, radius=expand_radius)

saline_dbs-0.3.0/saline/volume.py

@@ -0,0 +1,6 @@
+import nibabel as nib
+
+
+def get_shape(path):
+    """Return the (dim1, dim2, dim3) voxel shape of a NIfTI volume at `path`."""
+    return nib.load(path).get_fdata().shape

saline_dbs-0.3.0/saline_dbs.egg-info/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: saline-dbs
+Version: 0.3.0
+Summary: SALINE: filter-based localization and segmentation of DBS electrodes in clinical MRI
+Author: Vanessa H. Yu, Edward Chen, Jürgen Germann, Alexandre Boutet, Andres M. Lozano, Kâmil Uludağ, Sriranga Kashyap
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/srikash/SALINE
+Project-URL: Repository, https://github.com/srikash/SALINE
+Project-URL: Issues, https://github.com/srikash/SALINE/issues
+Project-URL: Paper, https://doi.org/10.1109/ISBI61048.2026.11515562
+Keywords: deep brain stimulation,dbs,electrode segmentation,mri,neuroimaging
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: nibabel
+Requires-Dist: scipy
+Requires-Dist: scikit-image
+Requires-Dist: scikit-learn
+Requires-Dist: click
+Requires-Dist: rich
+Requires-Dist: tqdm
+Dynamic: license-file
+
+# SALINE (part of DBS-ElecNet)
+## <b><ins>S</ins></b>egmentation <b><ins>A</ins></b>lgorithm using <b><ins>LIN</ins></b>e-fitting for <b><ins>E</ins></b>lectrodes
+
+*V. H. Yu et al., "DBS-ElecNet: Automated Localization and Segmentation of DBS Electrodes in Clinical MRI," 2026 IEEE 23rd International Symposium on Biomedical Imaging (ISBI), London, United Kingdom, 2026, pp. 1-4, doi:[10.1109/ISBI61048.2026.11515562](https://doi.org/10.1109/ISBI61048.2026.11515562)*
+
+Give SALINE a raw clinical T1-weighted MR image and it handles the rest: resampling, 
+skull-stripping (SynthStrip), bias correction (N4), and segmentation (SynthSeg) 
+all run via Docker, with no other install needed. It runs as a fully standalone CLI tool.
+
+It is the core of [DBS-ElecNet](https://github.com/BRAIN-TO/DBS-ElecNet)'s 
+classical (non-deep-learning) segmentation pipeline.
+
+## Why SALINE?
+
+SALINE is a classical, filtering-based automatic segmentation method for DBS
+electrodes: no training, no manual annotation, no GPU. Give it an MRI, a brain
+mask, and a SynthSeg segmentation, and it finds the electrode track with a
+Laplacian/Frangi filter cascade and a line fit.
+
+That makes it well suited to building a large database of electrode
+segmentations, at scale, without a human labeling each scan by hand. In the
+DBS-ElecNet paper, SALINE segmented 280 post-operative MRI scans in about 1.5
+minutes each, and those segmentations became the training data for
+DBS-ElecNet's 3D U-Net. Any similar segmentation model can be trained the
+same way: run SALINE over a cohort, use its output as ground truth.
+
+## Install
+
+Requires Python 3.12+ and [Docker](https://www.docker.com) (recommended; see
+below for running without it).
+
+```bash
+pip install git+https://github.com/srikash/SALINE.git@v0.3.0
+```
+
+## Usage
+
+Dual-electrode (default, also available explicitly as `saline dual`):
+
+```bash
+saline --input subject.nii.gz
+```
+
+Single-electrode:
+
+```bash
+saline single --input subject.nii.gz
+```
+
+`--input` is a raw, native-space clinical MRI. SALINE resamples it to 1mm
+isotropic, skull-strips it (SynthStrip), bias-corrects it (N4), and segments
+it (SynthSeg) before finding the electrode track. All of this runs via
+Docker, pulling [`antsx/ants`](https://hub.docker.com/r/antsx/ants),
+[`freesurfer/synthstrip`](https://hub.docker.com/r/freesurfer/synthstrip), and
+[`cookpa/synthseg`](https://hub.docker.com/r/cookpa/synthseg) on first use.
+
+**Output:**
+
+* `subject_saline_elecSeg.nii.gz`: the electrode segmentation, in `--input`'s native space.
+* `subject_1mm_iso.nii.gz`: the resampled MRI, kept for reference.
+* `subject_1mm_iso_saline_elecSeg.nii.gz`: the electrode segmentation, in 1mm-isotropic space.
+
+**Running without Docker:**
+
+If Docker isn't available, pass precomputed files instead. Both must already
+be in the same 1mm-isotropic space as `subject_1mm_iso.nii.gz`:
+
+* `--brain_mask PATH`: skips Docker-based SynthStrip.
+* `--synthseg PATH`: skips Docker-based SynthSeg.
+
+ANTs (resampling, N4, mask multiply) falls back to a local install
+(`ResampleImage`, `N4BiasFieldCorrection`, `ImageMath` on `PATH`) if Docker
+isn't available. There's no equivalent precomputed-file option for those.
+
+**Optional arguments:**
+
+* `--threads` (default `5`): threads for SynthSeg.
+* `--laplacian_threshold` (default `0.21`)
+* `--frangi_threshold` (default `0.25`)
+* `--lower_frangi_threshold` (default `0.2`): used if the higher threshold finds no candidates.
+* `--expand_radius` (default `6`): dilation radius applied to the final line mask.
+* `--save_intermediate`: also save the thresholded Laplacian, Frangi, and combined masks.
+
+## Citation
+
+If you use this in your work, please cite the paper above (see [`CITATION.cff`](CITATION.cff)
+for the full machine-readable record).
+
+## Releasing
+
+Publishing a GitHub Release triggers `.github/workflows/release.yml`, which
+builds the package and publishes it to PyPI via
+[trusted publishing](https://docs.pypi.org/trusted-publishers/) (no API token
+stored in the repo). One-time setup on PyPI, before the first release:
+add a trusted publisher on the `saline-dbs` project (or as a pending
+publisher if the project doesn't exist yet) pointing at this repository,
+workflow `release.yml`, environment `pypi`.

saline_dbs-0.3.0/saline_dbs.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+saline/__init__.py
+saline/cli.py
+saline/detect.py
+saline/external.py
+saline/fit.py
+saline/pipeline.py
+saline/segment.py
+saline/volume.py
+saline_dbs.egg-info/PKG-INFO
+saline_dbs.egg-info/SOURCES.txt
+saline_dbs.egg-info/dependency_links.txt
+saline_dbs.egg-info/entry_points.txt
+saline_dbs.egg-info/requires.txt
+saline_dbs.egg-info/top_level.txt

saline_dbs-0.3.0/saline_dbs.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

saline_dbs-0.3.0/saline_dbs.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+saline = saline.cli:main

saline_dbs-0.3.0/saline_dbs.egg-info/requires.txt

@@ -0,0 +1,8 @@
+numpy
+nibabel
+scipy
+scikit-image
+scikit-learn
+click
+rich
+tqdm

saline_dbs-0.3.0/saline_dbs.egg-info/top_level.txt

@@ -0,0 +1 @@
+saline

saline_dbs-0.3.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+