neuro-sam 0.1.0__py3-none-any.whl

neuro_sam/punet/run_inference.py

@@ -0,0 +1,145 @@
+
+import argparse
+from pathlib import Path
+
+import numpy as np
+import torch
+import tifffile as tiff
+from tqdm import tqdm
+
+from prob_unet_with_tversky import ProbabilisticUnetDualLatent
+
+
+def pad_to_multiple(img: np.ndarray, multiple: int = 32):
+    """Pad HxW to next multiple with reflect to keep context."""
+    H, W = img.shape
+    pad_h = (multiple - H % multiple) % multiple
+    pad_w = (multiple - W % multiple) % multiple
+    if pad_h == 0 and pad_w == 0:
+        return img, (0, 0)
+    img_p = np.pad(img, ((0, pad_h), (0, pad_w)), mode="reflect")
+    return img_p, (pad_h, pad_w)
+
+
+@torch.no_grad()
+def infer_slice(model, device, img_2d: np.ndarray, mc_samples: int = 8):
+    """
+    img_2d: float32 in [0,1], shape HxW
+    returns: (prob_dend, prob_spine) each HxW float32
+    """
+    # pad for UNet down/upsampling safety
+    x_np, (ph, pw) = pad_to_multiple(img_2d, multiple=32)
+    # to tensor [B,C,H,W] = [1,1,H,W]
+    x = torch.from_numpy(x_np).unsqueeze(0).unsqueeze(0).to(device)
+
+
+    model.forward(x, training=False)
+
+    # Multi-sample averaging from prior
+    pd_list, ps_list = [], []
+    for _ in range(max(1, mc_samples)):
+        ld, ls = model.sample(testing=True, use_posterior=False)
+        pd_list.append(torch.sigmoid(ld))
+        ps_list.append(torch.sigmoid(ls))
+
+    pd = torch.stack(pd_list, 0).mean(0)  # [1,1,H,W]
+    ps = torch.stack(ps_list, 0).mean(0)
+
+    # back to numpy, remove padding
+    pd_np = pd.squeeze().float().cpu().numpy()
+    ps_np = ps.squeeze().float().cpu().numpy()
+    if ph or pw:
+        pd_np = pd_np[: pd_np.shape[0] - ph, : pd_np.shape[1] - pw]
+        ps_np = ps_np[: ps_np.shape[0] - ph, : ps_np.shape[1] - pw]
+    return pd_np.astype(np.float32), ps_np.astype(np.float32)
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Inference on DeepD3_Benchmark.tif with Dual-Latent Prob-UNet")
+    ap.add_argument("--weights", required=True, help="Path to checkpoint .pth (with model_state_dict)")
+    ap.add_argument("--tif", required=True, help="Path to DeepD3_Benchmark.tif")
+    ap.add_argument("--out", required=True, help="Output directory")
+    ap.add_argument("--samples", type=int, default=16, help="MC samples per slice (default: 8)")
+    ap.add_argument("--thr_d", type=float, default=0.5, help="Threshold for dendrite mask save")
+    ap.add_argument("--thr_s", type=float, default=0.5, help="Threshold for spine mask save")
+    ap.add_argument("--save_bin", action="store_true", help="Also save thresholded uint8 masks")
+    args = ap.parse_args()
+
+    outdir = Path(args.out)
+    outdir.mkdir(parents=True, exist_ok=True)
+
+    if torch.cuda.is_available():
+        device = torch.device("cuda")
+    elif torch.backends.mps.is_available():
+        device = torch.device("mps")
+    else:
+        device = torch.device("cpu")
+    print(f"Device: {device}")
+
+    model = ProbabilisticUnetDualLatent(
+        input_channels=1,
+        num_classes=1,
+        num_filters=[32, 64, 128, 192],
+        latent_dim_dendrite=12,
+        latent_dim_spine=12,
+        no_convs_fcomb=4,
+        recon_loss="tversky",        
+        tversky_alpha=0.3, tversky_beta=0.7, tversky_gamma=1.0,
+        beta_dendrite=1.0, beta_spine=1.0,
+        loss_weight_dendrite=1.0, loss_weight_spine=1.0,
+    ).to(device)
+    model.eval()
+
+    # Load checkpoint
+    print(f"Loading checkpoint: {args.weights}")
+    ckpt = torch.load(args.weights, map_location=device, weights_only=False)
+    state = ckpt.get("model_state_dict", ckpt) 
+    model.load_state_dict(state, strict=True)
+
+    print(f"Reading: {args.tif}")
+    vol = tiff.imread(args.tif)  # shape: (Z,H,W) or (H,W)
+    if vol.ndim == 2:
+        vol = vol[np.newaxis, ...]
+    Z, H, W = vol.shape
+    print(f"Volume shape: Z={Z}, H={H}, W={W}")
+
+    # Output arrays (float32)
+    prob_d = np.zeros((Z, H, W), dtype=np.float32)
+    prob_s = np.zeros((Z, H, W), dtype=np.float32)
+
+    # ----- Run inference per slice -----
+    for z in tqdm(range(Z), desc="Inferring"):
+        img = vol[z].astype(np.float32)
+        # per-slice min-max normalize , avoid div by zero
+        vmin, vmax = float(img.min()), float(img.max())
+        if vmax > vmin:
+            img = (img - vmin) / (vmax - vmin)
+        else:
+            img = np.zeros_like(img, dtype=np.float32)
+
+        pd, ps = infer_slice(model, device, img, mc_samples=args.samples)
+        prob_d[z] = pd
+        prob_s[z] = ps
+
+    prob_d_path = outdir / "DeepD3_Benchmark_prob_dendrite.tif"
+    prob_s_path = outdir / "DeepD3_Benchmark_prob_spine.tif"
+    tiff.imwrite(prob_d_path.as_posix(), prob_d, dtype=np.float32)
+    tiff.imwrite(prob_s_path.as_posix(), prob_s, dtype=np.float32)
+    print(f"Saved: {prob_d_path}")
+    print(f"Saved: {prob_s_path}")
+
+    if args.save_bin:
+        bin_d = (prob_d >= args.thr_d).astype(np.uint8) * 255
+        bin_s = (prob_s >= args.thr_s).astype(np.uint8) * 255
+        bin_d_path = outdir / f"DeepD3_Benchmark_mask_dendrite_thr{args.thr_d:.2f}.tif"
+        bin_s_path = outdir / f"DeepD3_Benchmark_mask_spine_thr{args.thr_s:.2f}.tif"
+        tiff.imwrite(bin_d_path.as_posix(), bin_d, dtype=np.uint8)
+        tiff.imwrite(bin_s_path.as_posix(), bin_s, dtype=np.uint8)
+        print(f"Saved: {bin_d_path}")
+        print(f"Saved: {bin_s_path}")
+
+    print("Done.")
+
+
+if __name__ == "__main__":
+    main()

neuro_sam/punet/unet_blocks.py

@@ -0,0 +1,81 @@
+import torch
+import torch.nn as nn
+from torch.autograd import Variable
+import numpy as np
+from utils import init_weights
+
+class DownConvBlock(nn.Module):
+    """
+    A block of three convolutional layers where each layer is followed by a non-linear activation function
+    Between each block we add a pooling operation.
+    """
+    def __init__(self, input_dim, output_dim, initializers, padding, pool=True):
+        super(DownConvBlock, self).__init__()
+        layers = []
+
+        if pool:
+            #layers.append(nn.AvgPool2d(kernel_size=2, stride=2, padding=0, ceil_mode=True))
+            layers.append(nn.AdaptiveAvgPool2d((None, None)))
+            layers.append(nn.AvgPool2d(kernel_size=2, stride=2))
+
+        layers.append(nn.Conv2d(input_dim, output_dim, kernel_size=3, stride=1, padding=int(padding)))
+        layers.append(nn.ReLU(inplace=True))
+        layers.append(nn.Conv2d(output_dim, output_dim, kernel_size=3, stride=1, padding=int(padding)))
+        layers.append(nn.ReLU(inplace=True))
+        layers.append(nn.Conv2d(output_dim, output_dim, kernel_size=3, stride=1, padding=int(padding)))
+        layers.append(nn.ReLU(inplace=True))
+
+        self.layers = nn.Sequential(*layers)
+
+        self.layers.apply(init_weights)
+
+    def forward(self, patch):
+        return self.layers(patch)
+
+
+class UpConvBlock(nn.Module):
+    """
+    A block consists of an upsampling layer followed by a convolutional layer to reduce the amount of channels and then a DownConvBlock
+    If bilinear is set to false, we do a transposed convolution instead of upsampling
+    """
+    def __init__(self, input_dim, output_dim, initializers, padding, bilinear=True):
+        super(UpConvBlock, self).__init__()
+        self.bilinear = bilinear
+
+        if not self.bilinear:
+            self.upconv_layer = nn.ConvTranspose2d(input_dim, output_dim, kernel_size=2, stride=2)
+            self.upconv_layer.apply(init_weights)
+
+        self.conv_block = DownConvBlock(input_dim, output_dim, initializers, padding, pool=False)
+
+    # def forward(self, x, bridge):
+    #     if self.bilinear:
+    #         up = nn.functional.interpolate(x, mode='bilinear', scale_factor=2, align_corners=True)
+    #     else:
+    #         up = self.upconv_layer(x)
+        
+    #     assert up.shape[3] == bridge.shape[3]
+    #     out = torch.cat([up, bridge], 1)
+    #     out =  self.conv_block(out)
+
+    #     return out
+
+    def forward(self, x, bridge):
+        # if self.bilinear:
+        #     up = nn.functional.interpolate(x, size=bridge.shape[2:], mode='bilinear', align_corners=True)
+        # else:
+        #     up = self.upconv_layer(x)
+        if self.bilinear:
+            up = nn.functional.interpolate(x, size=bridge.shape[2:], mode='bilinear', align_corners=True)
+        else:
+            up = self.upconv_layer(x)
+
+        # Instead of assert, handle mismatches dynamically
+        diffY = bridge.size()[2] - up.size()[2]
+        diffX = bridge.size()[3] - up.size()[3]
+
+        up = nn.functional.pad(up, [diffX // 2, diffX - diffX // 2, diffY // 2, diffY - diffY // 2])
+
+        out = torch.cat([up, bridge], 1)
+        out = self.conv_block(out)
+        return out

neuro_sam/punet/utils.py

@@ -0,0 +1,52 @@
+# File: utils.py (Updated for Hierarchical Probabilistic U-Net)
+
+import torch
+import torch.nn as nn
+import matplotlib.pyplot as plt
+import numpy as np
+
+def truncated_normal_(tensor, mean=0, std=1):
+    size = tensor.shape
+    tmp = tensor.new_empty(size + (4,)).normal_()
+    valid = (tmp < 2) & (tmp > -2)
+    ind = valid.max(-1, keepdim=True)[1]
+    tensor.data.copy_(tmp.gather(-1, ind).squeeze(-1))
+    tensor.data.mul_(std).add_(mean)
+
+def init_weights(m):
+    if isinstance(m, (nn.Conv2d, nn.ConvTranspose2d)):
+        nn.init.kaiming_normal_(m.weight, mode='fan_in', nonlinearity='relu')
+        truncated_normal_(m.bias, mean=0, std=0.001)
+
+def init_weights_orthogonal_normal(m):
+    if isinstance(m, (nn.Conv2d, nn.ConvTranspose2d)):
+        nn.init.orthogonal_(m.weight)
+        truncated_normal_(m.bias, mean=0, std=0.001)
+
+def l2_regularisation(m):
+    l2_reg = None
+    for W in m.parameters():
+        if l2_reg is None:
+            l2_reg = W.norm(2)
+        else:
+            l2_reg = l2_reg + W.norm(2)
+    return l2_reg
+
+# Latent Visualization for Experimentation
+def visualize_latent_distribution(latent_list, title_prefix=""):
+    for idx, z in enumerate(latent_list):
+        mean = z.base_dist.loc.mean().item()
+        std = z.base_dist.scale.mean().item()
+        print(f"{title_prefix} Latent Level {idx+1} -> Mean: {mean:.4f}, Std: {std:.4f}")
+
+# Save Prediction and Mask Images for Debugging
+def save_mask_prediction_example(mask, pred, iter_id, save_path='images/'):
+    plt.imshow(pred, cmap='Greys')
+    plt.axis('off')
+    plt.savefig(f'{save_path}{iter_id}_prediction.png', bbox_inches='tight')
+    plt.close()
+
+    plt.imshow(mask, cmap='Greys')
+    plt.axis('off')
+    plt.savefig(f'{save_path}{iter_id}_mask.png', bbox_inches='tight')
+    plt.close()

neuro_sam-0.1.0.dist-info/METADATA

@@ -0,0 +1,269 @@
+Metadata-Version: 2.4
+Name: neuro-sam
+Version: 0.1.0
+Summary: Neuro-SAM: Foundation Models for Dendrite and Dendritic Spine Segmentation
+Author-email: Nipun Arora <nipun.arora@fau.de>
+License: MIT License
+        
+        Copyright (c) 2024 Nipun Arora
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/nipunarora8/Neuro-SAM
+Project-URL: Bug Tracker, https://github.com/nipunarora8/Neuro-SAM/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Framework :: napari
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: napari
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: imageio
+Requires-Dist: torch>=2.0.0
+Requires-Dist: torchvision>=0.15.0
+Requires-Dist: hydra-core>=1.3.2
+Requires-Dist: iopath>=0.1.10
+Requires-Dist: pillow>=9.4.0
+Requires-Dist: tqdm>=4.66.1
+Requires-Dist: vispy
+Requires-Dist: qtpy
+Requires-Dist: superqt
+Requires-Dist: magicgui
+Requires-Dist: scikit-image
+Requires-Dist: tifffile
+Dynamic: license-file
+
+<div align="center">
+
+# Neuro-SAM 
+#### Foundation Models from Dendrite and Dendritic Spine Segmentation
+
+[![python](https://img.shields.io/badge/-Python_3.10-blue?logo=python&logoColor=white)](https://github.com/pre-commit/pre-commit)
+[![pytorch](https://img.shields.io/badge/PyTorch_2.0+-ee4c2c?logo=pytorch&logoColor=white)](https://pytorch.org/get-started/locally/)
+[![wandb](https://img.shields.io/badge/Weights_&_Biases-FFCC33?logo=WeightsAndBiases&logoColor=black)](https://wandb.ai/site)
+
+This project demonstrates an interactive UI to segment dendrites and dendritic spines.
+The model of choice is SAMv2 and the framework used is pytorch.
+
+![A stack of neural dendrites and dendritic spines](./assets/merged_dendrites_spines.gif "Dendrites and Dendritic Spines")
+
+</div>
+
+### 📝  Table of Contents
+
+- [Neuro-SAM](#neuro-sam)
+  - [📑 Table of Contents](#--table-of-contents)
+  - [🧠 Overview](#-overview)
+  - [📦 Built With](#-built-with)
+  - [📂 Repository Structure](#-repository-structure)
+  - [🚀 Installation](#-installation)
+  - [📊 Usage](#-usage)
+  - [🛠 Workflow](#-workflow)
+  - [🧑‍💻 Model Training](#-model-training)
+  - [📁 Data Format](#-data-format)
+  - [📄 License](#-license)
+  - [📬 Contact](#-contact)
+
+
+### 🧠 Overview
+
+Neuro-SAM provides an end-to-end pipeline for analyzing neural structures from 3D microscopy data, featuring:
+
+- **Path Tracing**: Waypoint-based A* pathfinding
+- **Dendrite Segmentation**: SAM2-based dendrite segmentation
+- **Smart Spine Detection**: Multi-view analysis for spine detection
+- **Spine Segmentation**: Individual spine segmentation using trained SAM2 model
+
+### 📦 Built With
+
+[PyTorch](https://pytorch.org) - an open-source machine learning library for Python, widely used for deep learning applications.
+
+[Segment Anything Model](https://segment-anything.com) - a foundation model used for segmentation built by Meta AI.
+
+[Weights and Biases](https://wandb.ai/site) - a tool for tracking and visualizing machine learning experiments.
+
+[Visual Studio Code](https://code.visualstudio.com/) - a code editor redefined and optimized for building applications.
+
+[FAU High Performance Computing](https://doc.nhr.fau.de/) - a high-performance computing cluster at Friedrich-Alexander-Universität Erlangen-Nürnberg.
+
+### 📁 Repository Structure
+
+```
+Neuro-SAM/
+├── Train-SAMv2/                    # SAM2 training infrastructure
+│   ├── sam2/                       # SAM2 model implementation
+│   ├── checkpoints/                # Model checkpoints
+│   ├── results/                    # Trained model outputs
+│   ├── utils/                      # Training utilities
+│   ├── train_dendrites.py         # Dendrite model training
+│   └── train_spines.py            # Spine model training
+├── brightest_path_lib/             # Advanced pathfinding algorithms
+│   ├── algorithm/                  # A* and waypoint search implementations
+│   ├── cost/                       # Cost function definitions
+│   ├── heuristic/                  # Heuristic functions
+│   ├── visualization/              # Path visualization tools
+│   └── ...
+├── napari_utils/                   # Napari plugin components
+│   ├── main_widget.py             # Main interface with anisotropic scaling
+│   ├── path_tracing_module.py     # Interactive path tracing
+│   ├── segmentation_module.py     # Dendrite segmentation interface
+│   ├── spine_detection_module.py  # Spine detection with smart tracking
+│   ├── spine_segmentation_module.py # Individual spine segmentation
+│   └── visualization_module.py    # Path management and visualization
+└── neuro_sam_plugin.py            # Main plugin entry point
+```
+
+### 🚀 Installation
+
+#### Prerequisites
+
+- Python 3.10+
+- CUDA-compatible GPU (recommended)
+- Conda/Miniconda
+
+#### Environment Setup
+
+1. **Clone the repository:**
+```bash
+git clone https://github.com/nipunarora8/Neuro-SAM.git
+cd Neuro-SAM
+```
+
+2. **Create local environment:**
+```bash
+conda create -p ./.venv python=3.10 -c conda-forge
+conda activate ./.venv
+```
+
+3. **Install dependencies:**
+```bash
+pip install uv
+uv sync
+```
+
+4. **Download SAM2 checkpoints:**
+```bash
+cd Train-SAMv2/checkpoints
+bash download_ckpts.sh
+```
+
+### 📊 Usage
+
+#### Quick Start
+
+```python
+from neuro_sam_plugin import run_neuro_sam
+
+# Launch with default spacing (94nm x 94nm x 500nm)
+viewer = run_neuro_sam(image_path="your_image.tif")
+
+# Launch with custom voxel spacing
+viewer = run_neuro_sam(
+    image_path="your_image.tif",
+    spacing_xyz=(100.0, 100.0, 300.0)  # X, Y, Z spacing in nm
+)
+```
+
+#### Command Line Interface
+
+```bash
+# Basic usage
+python neuro_sam_plugin.py --image_path /path/to/your/image.tif
+
+# Custom spacing
+python neuro_sam_plugin.py --image_path image.tif \
+    --x-spacing 100.0 --y-spacing 100.0 --z-spacing 300.0
+
+# Load benchmark dataset
+python neuro_sam_plugin.py
+```
+
+### 🔬 Workflow
+
+#### 1. **Configure Voxel Spacing**
+Set accurate X, Y, Z voxel spacing in the "Path Tracing" tab for proper anisotropic scaling:
+- Typical two-photon: 94nm × 94nm × 500nm
+- Confocal: varies by objective and zoom
+
+#### 2. **Trace Dendritic Paths**
+- Click waypoints along dendrite structures
+- Algorithm automatically finds optimal brightess paths
+
+#### 3. **Segment Dendrites**
+- Load pre-trained SAMv2 dendrite model
+- Segment individual path with SAMv2
+
+#### 4. **Detect Spines**
+- Smart multi-view detection using tube data generation
+- Angle-based matching between 2D and tubular views
+
+#### 5. **Segment Spines**
+- Fine-grained spine segmentation using specialized SAMv2 model
+- Dendrite mask overlay to suppress background signal
+- Manual point extension across frames
+- Contrasting color system for visualization
+
+### 🔧 Model Training
+
+#### Dendrite Model
+```bash
+cd Train-SAMv2
+python train_dendrites.py --ppn 20 --pnn 10 --batch_size 32 --model_name "small"
+```
+
+#### Spine Model  
+```bash
+python train_spines.py --model_name "small" --batch_size 16
+```
+
+### 📁 Data Format
+
+#### Input Requirements
+- **Image Format**: TIFF, .d3set (to reproduce training results)
+- **Dimensions**: 3D volumes (Z×Y×X) 
+- **Bit Depth**: 8-bit or 16-bit grayscale
+- **Size**: Tested up to 2048×2048×500 voxels
+
+#### Output Formats
+- **Paths**: NumPy arrays with coordinates
+- **Masks**: Binary TIFF volumes
+
+### 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+
+#### Useful VSCode Extensions
+
+- [Remote Explorer](https://marketplace.visualstudio.com/items?itemName=ms-vscode.remote-explorer) - Open projects on remote servers.
+- [Log Viewer](https://marketplace.visualstudio.com/items?itemName=berublan.vscode-log-viewer) - A log monitoring extension.
+- [Black Formatter](https://marketplace.visualstudio.com/items?itemName=ms-python.black-formatter) - Python auto code formatter.
+- [Markdown All in One](https://marketplace.visualstudio.com/items?itemName=yzhang.markdown-all-in-one) - Markdown preview and editing.
+
+### 📬  Contact
+
+Nipun Arora - nipun.arora@fau.de
+
+---
+<div align="center">
+<b>Made with ♥️ at Anki Lab 🧠✨</b>
+</div>

neuro_sam-0.1.0.dist-info/RECORD

@@ -0,0 +1,93 @@
+neuro_sam/__init__.py,sha256=0pbMqpI_nQyhP0_pfTaIg97FVEcFkS5w8gQrsMiBcG4,34
+neuro_sam/plugin.py,sha256=pL2zJtslbuinkXUOJFVbuGwSIVIf45wVGiPAJ2XUZ-I,10092
+neuro_sam/brightest_path_lib/__init__.py,sha256=vU3VvX26D2c9B26Lid09uThzKMQJYPx622SkPhxNlDI,123
+neuro_sam/brightest_path_lib/connected_componen.py,sha256=x_kjDGZ_8U2ks9kZJOOyM8_ow84UugAsPUByI-NlXFk,12734
+neuro_sam/brightest_path_lib/algorithm/__init__.py,sha256=XFYxFyx97FG7lK3_j7uA8GgunpfkOcAo2NIJU0GUn40,170
+neuro_sam/brightest_path_lib/algorithm/astar.py,sha256=3F506tW29_XFn6HCAqf-DucDNF1Fwlj_Zg5-FCvp_-I,24198
+neuro_sam/brightest_path_lib/algorithm/waypointastar.py,sha256=5XgrlRowyWVtwXCCTOCzFQ98ARFMb5FzcKGTVxUuPI0,17900
+neuro_sam/brightest_path_lib/algorithm/waypointastar_speedup.py,sha256=t8LySe-aDeGSRdITQqkMOU9RLgyAczBW7MQz0AoPDtg,44666
+neuro_sam/brightest_path_lib/cost/__init__.py,sha256=Fd92fQaAEu8BMxIJW6whLLTarxqI0WsA4-j0ZCbOsXk,223
+neuro_sam/brightest_path_lib/cost/cost.py,sha256=huHU_XMCIzgPMF3IZfs4T6b2cHkAjlW55xqswkTDLSc,788
+neuro_sam/brightest_path_lib/cost/reciprocal.py,sha256=lzGIUBBAJU0ao94hC6RW7XyLnhHknujD32qj5UW-CDQ,3203
+neuro_sam/brightest_path_lib/cost/reciprocal_transonic.py,sha256=lGAD1GbiYrq1BuuDrolsWsathz0ppp4C1eMqtKcc3-Q,2749
+neuro_sam/brightest_path_lib/heuristic/__init__.py,sha256=Fj7lnYrEGwaj-PrmFr_6XTs-uMEt32TthAVPamqlXnU,66
+neuro_sam/brightest_path_lib/heuristic/euclidean.py,sha256=i9YCgajbOvRAagSJcNcOIYiqZXRwFp8l5F6EDDGP6uE,3680
+neuro_sam/brightest_path_lib/heuristic/heuristic.py,sha256=mUli5G_HI-I79zoUHx593GcHBFJeySNEw3zlDku1bTk,936
+neuro_sam/brightest_path_lib/image/__init__.py,sha256=uFceEO4Y2eei_jhIlvKE3bGDRnwudbeOEzEhF2l-lVA,29
+neuro_sam/brightest_path_lib/image/stats.py,sha256=4KHxApJQ-Xqfer2Oeq8g9K-beXSwHe-9xkCRH4NTDOg,5951
+neuro_sam/brightest_path_lib/input/__init__.py,sha256=GneTu78tyNUnzPznl7zW43IIUpfsGIH5JMou9x18qaQ,67
+neuro_sam/brightest_path_lib/input/inputs.py,sha256=GqF5jnGs4eg3TC3083tpHquK434a_O3ppu6bk4iKrGs,290
+neuro_sam/brightest_path_lib/node/__init__.py,sha256=ADsvx8Okxzg-mPwBGFmK94oCjvHJwJvi7mgHzE8E5P0,72
+neuro_sam/brightest_path_lib/node/bidirectional_node.py,sha256=8goerVtkk8wXxD9HdwIU2kBA5UQt22yv7L-0eJPywOQ,9264
+neuro_sam/brightest_path_lib/node/node.py,sha256=Pfq8Swm3XWu6gErJlXzN7JyJ9J4bFsvJH1PDoELww8I,3779
+neuro_sam/brightest_path_lib/visualization/__init__.py,sha256=WZ1QT3JqhHquh3dxwXKeQ5vmfuBj70sNI0_JBzrNKNY,195
+neuro_sam/brightest_path_lib/visualization/flythrough.py,sha256=bs-rqgwEXUZOYUkN6FOZAl2FkcRus7Ma1jWtZ1VRA1Q,5087
+neuro_sam/brightest_path_lib/visualization/flythrough_all.py,sha256=3MIYTl2q3oVszuaLOl-QS4zQISsCk1JlVcURCtc-pw0,17886
+neuro_sam/brightest_path_lib/visualization/tube_data.py,sha256=b0YfKUWzk4FT6_mUdLexIp-s4ipLsiGDt20diweA4BM,15570
+neuro_sam/brightest_path_lib/visualization/tube_flythrough.py,sha256=Lt5sLqvj20AiiXl8SXlt6vQlHXQXtB91-FNFGl-YmU8,9160
+neuro_sam/napari_utils/anisotropic_scaling.py,sha256=VA6Sd9zEhIAhzjAGto2cOjE9mocNx9NFWXec2TQpvew,19266
+neuro_sam/napari_utils/color_utils.py,sha256=Hf5R8f0rh7b9CY1VT72o3tLGfGnnjRREkX8iWsiiu7k,4243
+neuro_sam/napari_utils/contrasting_color_system.py,sha256=a-lt_3zJLDL9YyIdWJhFDGMYzBb6yH85cV7BNCabbdI,6771
+neuro_sam/napari_utils/main_widget.py,sha256=yahfPLwmhBt_hImpRykIObzfMwbVZvVJTEKKzMZ11bw,48588
+neuro_sam/napari_utils/path_tracing_module.py,sha256=0mMAtrMmtgK_ujMzaWzIguYVDPr8nfzalaTAwgF3NaQ,44062
+neuro_sam/napari_utils/punet_widget.py,sha256=GzY8fGzx5xvitkIiD24TjWktW1ex4F7ujYjCu3Rd6xA,17058
+neuro_sam/napari_utils/segmentation_model.py,sha256=uAnNvMdZVrtlaST36TpCdyoYiaNtVsQLeaPcroD-aT0,33939
+neuro_sam/napari_utils/segmentation_module.py,sha256=MKp53jn3UM5fJurC9kAV6BcHpTJWjsmbno8bbSDMhHc,28988
+neuro_sam/napari_utils/visualization_module.py,sha256=JtZlBoKlfIwVLa2Sqg7b2KTr07fNlAcwR0M7fHsn2oM,24723
+neuro_sam/punet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+neuro_sam/punet/deepd3_model.py,sha256=nGVEqzCPz_E4cFA6QmknW2CffDcjxH7VsdYAyTdAtY0,7509
+neuro_sam/punet/prob_unet_deepd3.py,sha256=qZcKo4dZeEemqD7PxLHZu5YB_h3Q0--W3vTRhXjYxS0,14695
+neuro_sam/punet/prob_unet_with_tversky.py,sha256=D-Ur5AfGsVl2dH35jbZL8BaHdJHzbTrHLsS-cagBzoQ,12843
+neuro_sam/punet/punet_inference.py,sha256=U3ne-sP1y732PISFYlV50cPbXN6eEREQue1Jf6w1Io8,8032
+neuro_sam/punet/run_inference.py,sha256=c9ATKWJvhOzNEaww_sUCI5fFS1q0bQ4GYUwNUqxWcwA,5312
+neuro_sam/punet/unet_blocks.py,sha256=xc-nZql_CSsyEeCxKIY-WIhiXG1KyRiCSIESztGJKEs,3170
+neuro_sam/punet/utils.py,sha256=ibwcpkqqZ3_3Afz2VYxzplz8_8FWQ5qYQqjJiKS8hIo,1786
+neuro_sam-0.1.0.dist-info/licenses/LICENSE,sha256=akmTIN8IuZn3Y7UK_8qVQnyKDWSDcVUwB8RPGNXCojw,1068
+sam2/__init__.py,sha256=uHyh6VzVS4F2box0rPDpN5UmOVKeQNK0CIaTKG9JQZ4,395
+sam2/automatic_mask_generator.py,sha256=Zt8mbb4UQSMFrjOY8OwbshswOpMhaxAtdn5sTuXUw9c,18461
+sam2/benchmark.py,sha256=m3o1BriIQuwJAx-3zQ_B0_7YLhN84G28oQSV5sGA3ak,2811
+sam2/build_sam.py,sha256=hW1k1x5EQHQBKXtVGIT7TNGrqAgt4P9fxg-sPdQvCU0,6405
+sam2/sam2.1_hiera_b+.yaml,sha256=N9bFawen-NCLqqMUMVxg3Dqr4u3GbNkrrG0e1QA454g,3650
+sam2/sam2.1_hiera_l.yaml,sha256=Hb1stt_r6vWIxwBu4iLG77-pBJp61HKjzfsvXZGegQc,3798
+sam2/sam2.1_hiera_s.yaml,sha256=9esKA_9iFSgbSn5Q6VVenPBPO6m3eSSf-h-plULkPk4,3760
+sam2/sam2.1_hiera_t.yaml,sha256=-TLqwcYkHpEAMbLwAKgc2fio1IluInerX_tyHzeLGI0,3855
+sam2/sam2_hiera_b+.yaml,sha256=ZE0amqp-FBg4AiRt7k9DYn4GfXfdifH0DYNlfbGNA4s,3548
+sam2/sam2_hiera_l.yaml,sha256=DunyA3_ZhIkhK7C3ilbzOsgusXfPXlLIi-NxTLhO6iY,3696
+sam2/sam2_hiera_s.yaml,sha256=D8DFUj7pnY2tLv6UpAsUInpHKxUlas_1axCJSbTe_Jk,3658
+sam2/sam2_hiera_t.yaml,sha256=Mzmcc80Tu8PQwc6oQ_ovwlX9sgE5_gfwQnQ-BGrEa2s,3753
+sam2/sam2_image_predictor.py,sha256=ti8Ik23gi5FyQUVxRqcWWz6WEb8qaIgyQE1V-7U3_94,20295
+sam2/sam2_video_predictor.py,sha256=kGYJyUxkBJDQBvODdMeHKai7K8Z6sPQXYb9WNIMAULQ,58836
+sam2/sam2_video_predictor_legacy.py,sha256=4MBUES8hv6Y2IPICbIuy4PTihLE40JQmoI058uiCw_I,58777
+sam2/configs/train.yaml,sha256=MYgDHFACwrBODNKiJa5CsdF77USu8vP4_vbsD9lYGb0,10923
+sam2/configs/sam2/sam2_hiera_b+.yaml,sha256=ZE0amqp-FBg4AiRt7k9DYn4GfXfdifH0DYNlfbGNA4s,3548
+sam2/configs/sam2/sam2_hiera_l.yaml,sha256=DunyA3_ZhIkhK7C3ilbzOsgusXfPXlLIi-NxTLhO6iY,3696
+sam2/configs/sam2/sam2_hiera_s.yaml,sha256=D8DFUj7pnY2tLv6UpAsUInpHKxUlas_1axCJSbTe_Jk,3658
+sam2/configs/sam2/sam2_hiera_t.yaml,sha256=Mzmcc80Tu8PQwc6oQ_ovwlX9sgE5_gfwQnQ-BGrEa2s,3753
+sam2/configs/sam2.1/sam2.1_hiera_b+.yaml,sha256=N9bFawen-NCLqqMUMVxg3Dqr4u3GbNkrrG0e1QA454g,3650
+sam2/configs/sam2.1/sam2.1_hiera_l.yaml,sha256=Hb1stt_r6vWIxwBu4iLG77-pBJp61HKjzfsvXZGegQc,3798
+sam2/configs/sam2.1/sam2.1_hiera_s.yaml,sha256=Dza5HobljQbIfkKZcWYhJGi4i5i2Dk2BbV5NTQiLb1U,3761
+sam2/configs/sam2.1/sam2.1_hiera_t.yaml,sha256=-TLqwcYkHpEAMbLwAKgc2fio1IluInerX_tyHzeLGI0,3855
+sam2/configs/sam2.1_training/sam2.1_hiera_b+_MOSE_finetune.yaml,sha256=2WkZ4VdScRbDqAxuyWEVG9qY5euYiuTdhb5ufvvStR8,11256
+sam2/modeling/__init__.py,sha256=NL2AacVHZOe41zp4kF2-ZGcUCi9zFwh1Eo9spNjN0Ko,197
+sam2/modeling/memory_attention.py,sha256=BzWMt_WOw3iOiP9OZBX4qdYoo5Y1KdbiyRVJSlNHyOI,5509
+sam2/modeling/memory_encoder.py,sha256=c_cImuX9rN_Krz3socptn4TYnn3rnPl1iWIqnvF7pC8,5657
+sam2/modeling/position_encoding.py,sha256=tRQEcYwNOPOBKTyOXgChXRKWUbfwmxFYAC2JdKMJZ7U,8980
+sam2/modeling/sam2_base.py,sha256=yMZRXd-q1BB3o5L_oR1g_8iiyiCb-bxg1-LNei-92LE,47056
+sam2/modeling/sam2_utils.py,sha256=41u_E7wuVEoCcs0_lTmvOKdSZ2rDzXRL4xzYIgr-6AQ,13173
+sam2/modeling/backbones/__init__.py,sha256=NL2AacVHZOe41zp4kF2-ZGcUCi9zFwh1Eo9spNjN0Ko,197
+sam2/modeling/backbones/hieradet.py,sha256=A3hVgcowTQRRrg33oI7gvx4dvmb60oUGbmuf_A2I1k8,10003
+sam2/modeling/backbones/image_encoder.py,sha256=FuqtIyIgOG9RDKjfq4ZV5jaZl3FJpNr5zpxvN05nd6k,4706
+sam2/modeling/backbones/utils.py,sha256=xKBlfbKpK9oqf_EWzUAX9rHFmvZAgJPYh06wig30dq0,3007
+sam2/modeling/sam/__init__.py,sha256=NL2AacVHZOe41zp4kF2-ZGcUCi9zFwh1Eo9spNjN0Ko,197
+sam2/modeling/sam/mask_decoder.py,sha256=yjUjxYNlV0-t3xv7VPN05LS-ugUScYXqKxfSK5FuCZo,12657
+sam2/modeling/sam/prompt_encoder.py,sha256=SWXMtKRQSqTXJGsq1m_-rNJiZBXIaiYdwcZf_Yrh1A0,7541
+sam2/modeling/sam/transformer.py,sha256=zaGQUjMed1GQzosRWe_LgopGMtkxpti9TUcQnxIXgvE,10761
+sam2/utils/__init__.py,sha256=NL2AacVHZOe41zp4kF2-ZGcUCi9zFwh1Eo9spNjN0Ko,197
+sam2/utils/amg.py,sha256=t7MwkOKvcuBNu4FcjzKv9BpO0av5Zo9itZ8b3WQMpdg,12842
+sam2/utils/misc.py,sha256=AWAMAcFhzQedcQb7HU2oRc-RqjGrK87K-MsVG21tIKI,13090
+sam2/utils/transforms.py,sha256=ujpk9GAMYvIJIGpt87QOP88TPtrjL61liDG7DCptEUY,4885
+neuro_sam-0.1.0.dist-info/METADATA,sha256=qmJWJ17j0Qlm65saFelge2KlmpYQYdU48uq0CKykyJM,9509
+neuro_sam-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+neuro_sam-0.1.0.dist-info/entry_points.txt,sha256=Mw5mxn4u8N-boA1NOR8vfbPh_JbSiKpiIuqJ-styL9M,52
+neuro_sam-0.1.0.dist-info/top_level.txt,sha256=yPbWxFcw79sErTk8zohihUHMK9LL31i3bXir2MrS4OQ,15
+neuro_sam-0.1.0.dist-info/RECORD,,

neuro_sam-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

neuro_sam-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[napari.manifest]
+neuro-sam = neuro_sam:napari.yaml

neuro_sam-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Nipun Arora
+
+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.

neuro_sam-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+neuro_sam
+sam2