A deep learning pipeline for mapping in situ network-level neurovascular coupling in multi-photon fluorescence microscopy.

Code ↔ Paper

5 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 5 matches

[1] § Methods › Segmentation and graph extraction › Model architecture ↔ novas3d/predict.py, lines 151 to 231 · score 0.74 · hidden layer, PyTorch, perceptron, dropout, weighted, map · Report a mismatch
[2] § Methods › Segmentation and graph extraction › Model architecture ↔ novas3d/predict.py, lines 151 to 231 · score 0.66 · residual blocks, UNETR model, dropout, layers, weights, training · Report a mismatch
[3] § Methods › Segmentation and graph extraction › Graph extraction of cerebrovascular networks ↔ novas3d/vessel_graph.py, lines 543 to 689 · score 0.63 · Richardson Lucy, gradient, Gaussian, smoothed, filter, sigma · Report a mismatch
[4] § Methods › Segmentation and graph extraction › Graph extraction of cerebrovascular networks ↔ novas3d/predict.py, lines 233 to 285 · score 0.63 · sliding window inference, ROI, prediction, model · Report a mismatch
[5] § Methods › Segmentation and graph extraction › Graph extraction of cerebrovascular networks ↔ novas3d/vessel_graph.py, lines 264 to 340 · score 0.58 · connected component, segmentation mask, iteratively, filled, union, binary · Report a mismatch

Paper

Loaded from Europe PMC by your browser; OSCR does not store it: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The paper is loaded by your browser, with JavaScript: read it at doi.org or on Europe PMC.

The authors' code

Python · 483 lines · 19 KB · GPL-3.0 · 3 matches

from monai.utils import (
ensure_tuple
)
from monai.transforms import (
AsDiscrete,
EnsureChannelFirstd,
Compose,
LoadImaged,
ScaleIntensityRanged,
Spacingd,
EnsureTyped,
EnsureType,
)
from monai.handlers.utils import from_engine
from monai.networks.nets import UNETR
from monai.networks.layers import Norm
from monai.inferers import sliding_window_inference
from monai.data import (
DataLoader,
Dataset,
ImageReader
)
from monai.config import (
KeysCollection,
PathLike
)
import torch
import matplotlib.pyplot as plt
from os.path import exists
import os
from pathlib import Path
from re import sub
from skimage.io import imread
from typing import (
Optional,
Union,
Sequence,
Dict,
List
)
from monai.data.utils import is_supported_format
from monai. data.image_reader import (
_copy_compatible_dict,
_stack_images
)
from nibabel.nifti1 import Nifti1Image
from numpy import swapaxes, ndarray, eye, asarray, delete, empty, float16, save
from tqdm import tqdm
from monai.data import DataLoader, Dataset
from torch import no_grad
import pickle
import warnings
warnings.filterwarnings('ignore')
class TIFFReader(ImageReader):
def __init__(self, npz_keys: Optional[KeysCollection] = None, channel_dim: Optional[int] = None, **kwargs):
super().__init__()
if npz_keys is not None:
npz_keys = ensure_tuple(npz_keys)
self.npz_keys = npz_keys
self.channel_dim = channel_dim
self.kwargs = kwargs
def verify_suffix(self, filename: Union[Sequence[PathLike], PathLike]) -> bool:
"""
Verify whether the specified file or files format is supported by Numpy reader.
Args:
filename: file name or a list of file names to read.
if a list of files, verify all the suffixes.
Returns:
bool: True if the file format is supported, False otherwise.
"""
suffixes: Sequence[str] = ["tif", "tiff"]
return is_supported_format(filename, suffixes)
def read(self, data: Union[Sequence[PathLike], PathLike], **kwargs):
"""
Read image data from specified file or files, it can read a list of `no-channel` data files
and stack them together as multi-channels data in `get_data()`.
Note that the returned object is Numpy array or list of Numpy arrays.
Args:
data (Union[Sequence[PathLike], PathLike]): The file name or a list of file names to read.
**kwargs: Additional arguments for the `numpy.load` API except `allow_pickle`, which will override `self.kwargs` for existing keys.
More details about available arguments can be found here: https://numpy.org/doc/stable/reference/generated/numpy.load.html
Returns:
Union[numpy.ndarray, List[numpy.ndarray]]: The loaded image data as a Numpy array or a list of Numpy arrays.
"""
img_: List[Nifti1Image] = []
filenames: Sequence[PathLike] = ensure_tuple(data)
kwargs_ = self.kwargs.copy()
kwargs_.update(kwargs)
for name in filenames:
img = imread(name, **kwargs_)
img = img.astype('float32')
if len(img.shape)==4:
img = swapaxes(img,0,1)
img = swapaxes(img,1,3)
img_.append(img)
return img_ if len(img_) > 1 else img_[0]
def get_data(self, img):
"""
Extract data array and meta data from loaded image and return them.
This function returns two objects, first is numpy array of image data, second is dict of meta data.
It constructs `affine`, `original_affine`, and `spatial_shape` and stores them in meta dict.
When loading a list of files, they are stacked together at a new dimension as the first dimension,
and the meta data of the first image is used to represent the output meta data.
Args:
img: a Numpy array loaded from a file or a list of Numpy arrays.
Returns:
Tuple: A tuple containing the following two objects:
- img_array (numpy.ndarray): Numpy array of image data.
- compatible_meta (dict): Dictionary of meta data.
"""
img_array: List[ndarray] = []
compatible_meta: Dict = {}
if isinstance(img, ndarray):
img = (img,)
for i in ensure_tuple(img):
header = {"affine":eye(5),
"labels": {"0": "background",
"1": "vessels",
"2": "neurons",}
}
if isinstance(i, ndarray):
# if `channel_dim` is None, can not detect the channel dim, use all the dims as spatial_shape
spatial_shape = asarray(i.shape)
if isinstance(self.channel_dim, int):
spatial_shape = delete(spatial_shape, self.channel_dim)
header["spatial_shape"] = spatial_shape
img_array.append(i)
header["original_channel_dim"] = self.channel_dim if isinstance(self.channel_dim, int) else "no_channel"
_copy_compatible_dict(header, compatible_meta)
return _stack_images(img_array, compatible_meta), compatible_meta
def get_model(parameter_file='NOVAS3D_Vessel_and_Neuron_Segmentation/parameters.pickle',
spatial_dims=3,
in_channels=2,
out_channels=3,
img_size=(128, 128, 128),
feature_size=16,
hidden_size=768,
mlp_dim=3072,
pos_embed="perceptron",
res_block=True,
norm_name="instance",
gpu = False):
"""
Get the UNETR model for prediction.
Args:
parameter_file (str): Path to the parameter pickle file.
spatial_dims (int): Number of spatial dimensions.
in_channels (int): Number of input channels.
out_channels (int): Number of output channels.
img_size (tuple): Size of the input image.
feature_size (int): Size of the feature maps.
hidden_size (int): Size of the hidden layers.
mlp_dim (int): Dimension of the MLP layers.
pos_embed (str): Type of positional embedding.
res_block (bool): Whether to use residual blocks.
norm_name (str): Name of the normalization layer.
Returns:
torch.nn.Module: The UNETR model for prediction.
"""
# Load parameters from pickle file
with open(parameter_file, 'rb') as handle:
params = pickle.load(handle)
# Set device for model prediction
device = torch.device("cuda" if (torch.cuda.is_available() and gpu == True) else "cpu")
# Create UNETR model
model = UNETR(
spatial_dims=spatial_dims,
in_channels=in_channels,
out_channels=out_channels,
img_size=img_size,
feature_size=feature_size,
hidden_size=hidden_size,
mlp_dim=mlp_dim,
pos_embed=pos_embed,
res_block=res_block,
norm_name=norm_name,
dropout_rate=params["dropout"]
)
# Move model to device
model.to(device)
if (torch.cuda.is_available() and gpu == True):
# Use DataParallel for multi-GPU training
model = torch.nn.DataParallel(model)
# Load pre-trained model weights
model.load_state_dict(torch.load(
sub('parameters.pickle', "model.pth",parameter_file)))
else:
from collections import OrderedDict
state_dict = torch.load(sub('parameters.pickle', "model.pth",parameter_file), map_location='cpu')
new_state_dict = OrderedDict()
for k, v in state_dict.items():
new_state_dict[k.replace("module.", "")] = v
model.load_state_dict(new_state_dict)
# Load pre-trained model weights
#model.load_state_dict(torch.load(
# sub('parameters.pickle', "model.pth",parameter_file),
# map_location=torch.device('cpu')))
model.eval()
for m in model.modules():
if m.__class__.__name__.startswith('Dropout'):
m.train()
return model
def predict(pred_data,
num_evals=20,
num_channels_out=3,
model = get_model(),
device='cpu',
roi_size = (128, 128, 128),
sw_batch_size = 64):
"""
Perform prediction using a sliding window inference approach.
Args:
pred_data (dict): Dictionary containing the input data for prediction.
num_evals (int, optional): Number of evaluations to perform. Defaults to 20.
num_channels_out (int, optional): Number of output channels. Defaults to 3.
model (nn.Module, optional): Model to use for prediction. Defaults to get_model().
device (str, optional): Device to use for computation. Defaults to 'cpu'.
roi_size (tuple, optional): Size of the region of interest. Defaults to (128, 128, 128).
sw_batch_size (int, optional): Batch size for sliding window inference. Defaults to 64.
Returns:
numpy.ndarray: Array containing the predicted outputs.
"""
# Get the shape of the input image
_shape = pred_data["image"].shape
# Create an empty array to store the predicted outputs
pred_array = empty((num_evals,num_channels_out,_shape[2],_shape[3],_shape[4]),dtype=float16)
# Perform sliding window inference for the specified number of evaluations
for j in range(num_evals):
# define softmax for the predicted outputs
softmax = torch.nn.Softmax(dim=1)
# Perform sliding window inference
pred_outputs = sliding_window_inference(
pred_data["image"],
roi_size,
sw_batch_size,
model,
sw_device=device,
device=device
)
# Apply softmax to the predicted outputs
pred_outputs = softmax(pred_outputs)
# Convert the predicted outputs to numpy array of float16 data type
pred_outputs = float16(pred_outputs.cpu().detach().numpy())
# Store the predicted outputs in the pred_array
pred_array[j] = pred_outputs[:]
del pred_outputs
return pred_array
def get_pred_transforms(spacing=(1, 1, 0.375), i_min=0, i_max=1024, b_min=0.0, b_max=1.0, clip=True, channel_dim=0):
"""
Returns a composition of transforms for preprocessing the input image for prediction.
Args:
spacing (tuple): Voxel spacing in the input image. Default is (1, 1, 0.375).
i_min (int): Minimum intensity value for rescaling. Default is 0.
imax (int): Maximum intensity value for rescaling. Default is 1024.
b_min (float): Minimum intensity value for scaling. Default is 0.0.
b_max (float): Maximum intensity value for scaling. Default is 1.0.
clip (bool): Whether to clip the intensity values. Default is True.
channel_dim (int): Dimension index for channel. Default is 0.
Returns:
pred_transforms (Compose): Composition of transforms for preprocessing the input image.
"""
# Define a composition of transforms
pred_transforms = Compose(
[
LoadImaged(keys=["image"], reader=TIFFReader(channel_dim=channel_dim)), # Load the image using TIFFReader
EnsureChannelFirstd(keys=["image"]), # Ensure the channel dimension is first
Spacingd(keys=["image"], pixdim=spacing, mode=("bilinear")), # Resample the image with the given spacing
ScaleIntensityRanged(
keys=["image"], a_min=i_min, a_max=i_max, b_min=b_min, b_max=b_max, clip=clip
), # Rescale the intensity values of the image
EnsureTyped(keys=["image"]), # Ensure the image is of the correct data type
]
)
return pred_transforms
def get_post_transforms():
"""
Returns the post-processing transforms for the prediction.
Returns:
Compose: A composition of post-processing transforms.
"""
# Define post-processing transforms for prediction
post_pred = Compose(
[
EnsureType(),
AsDiscrete(argmax=True, to_onehot=3)
]
)
return post_pred
class PredictWarped:
"""
Class for performing prediction using the registered images. Saves the predicted images.
Args:
data_dict (dict): A dictionary containing the data for prediction.
config (dict): A dictionary containing the configuration parameters.
The configuration parameters include:
- in_dir (str): The input directory.
- out_dir (str): The output directory.
- num_evals (int): The number of evaluations.
- base_file_extension (str): The base file extension.
- pred_file_extension (str): The prediction file extension.
- mean_file_extension (str): The mean file extension.
parameter_file (str): The file path to the parameter file.
spatial_dims (int): The number of spatial dimensions.
in_channels (int): The number of input channels.
out_channels (int): The number of output channels.
img_size (tuple): The size of the input image.
feature_size (int): The size of the features.
hidden_size (int): The size of the hidden layers.
mlp_dim (int): The dimension of the MLP layers.
pos_embed (bool): Whether to use positional embedding.
res_block (bool): Whether to use residual blocks.
norm_name (str): The name of the normalization method.
spacing (tuple): The spacing between voxels. Reciprocal of the voxel size in um to resample to 1 um.
i_min (float): The minimum intensity value of raw images.
i_max (float): The maximum intensity value of raw images.
b_min (float): The minimum background value after normalization.
b_max (float): The maximum background value after noramlization.
clip (bool): Whether to clip the values.
channel_dim (int): The dimension index of the colour channel.
gpu (bool): Whether to use the GPU.
skip_existing (bool): Whether to skip images that have already been predicted.
Methods:
get_model(): Retrieves the model for prediction.
get_pred_transforms(): Retrieves the prediction transforms.
dataset_creation(): Creates the dataset for prediction.
prediction(): Performs the prediction.
"""
def __init__(self, data_dict, config, parameter_file, spatial_dims, in_channels, out_channels, img_size, feature_size, hidden_size, mlp_dim, pos_embed, res_block, norm_name,spacing, i_min, i_max, b_min, b_max, clip, channel_dim, gpu=False, skip_existing=False):
self.data_dict = data_dict
self.config = config
self.parameter_file = parameter_file
self.spatial_dims = spatial_dims
self.in_channels = in_channels
self.out_channels = out_channels
self.img_size = img_size
self.feature_size = feature_size
self.hidden_size = hidden_size
self.mlp_dim = mlp_dim
self.pos_embed = pos_embed
self.res_block = res_block
self.norm_name = norm_name
self.spacing = spacing
self.i_min = i_min
self.i_max = i_max
self.b_min = b_min
self.b_max = b_max
self.clip = clip
self.channel_dim = channel_dim
self.gpu = gpu
self.skip_existing = skip_existing
def get_model(self):
"""
Get the model for prediction.
Returns:
model: The model for prediction.
"""
# Get the model for prediction
model = get_model(self.parameter_file,
self.spatial_dims,
self.in_channels,
self.out_channels,
self.img_size,
self.feature_size,
self.hidden_size,
self.mlp_dim,
self.pos_embed,
self.res_block,
self.norm_name,
self.gpu)
return model
def get_pred_transforms(self):
"""
Get the prediction transforms.
Returns:
pred_transforms (list): List of prediction transforms.
"""
# Get the prediction transforms
pred_transforms = get_pred_transforms(self.spacing,
self.i_min,
self.i_max,
self.b_min,
self.b_max,
self.clip,
self.channel_dim)
return pred_transforms
def dataset_creation(self):
"""
Create the dataset for prediction.
Returns:
pred_ds (Dataset): The dataset for prediction.
"""
# Create the dataset for prediction
data_dicts = self.data_dict
pred_transforms = get_pred_transforms(self.spacing, self.i_min, self.i_max, self.b_min, self.b_max, self.clip, self.channel_dim)
pred_ds = Dataset(data=data_dicts, transform=pred_transforms)
self.assertEqual(len(pred_ds), 3)
return pred_ds
def prediction(self):
"""
Perform prediction using the provided model and saves the data.
Returns:
None
"""
# Perform the prediction
model = get_model(self.parameter_file, self.spatial_dims, self.in_channels, self.out_channels, self.img_size, self.feature_size, self.hidden_size, self.mlp_dim, self.pos_embed, self.res_block, self.norm_name)
pred_transforms = get_pred_transforms(self.spacing, self.i_min, self.i_max, self.b_min, self.b_max, self.clip, self.channel_dim)
pred_ds = Dataset(data=self.data_dict, transform=pred_transforms)
pred_loader = DataLoader(pred_ds, batch_size=1, shuffle=False)
config = self.config
with no_grad():
for i, pred_data in tqdm(enumerate(pred_loader)):
if self.skip_existing==False:
new_file_name = sub(config["in_dir"], config["out_dir"], self.data_dict[i]["image"])
pred_array = predict(pred_data, num_evals=config["num_evals"], model=model)
#self.assertIsNotNone(pred_array)
mean = float16(pred_array.mean(axis=0))
save(sub(config["base_file_extension"], config['mean_file_extension'], new_file_name), mean)
save(sub(config["base_file_extension"], config["pred_file_extension"], new_file_name), pred_array)
elif not exists(sub(config["base_file_extension"], config["pred_file_extension"], sub(config["in_dir"], config["out_dir"], self.data_dict[i]["image"]))):
new_file_name = sub(config["in_dir"], config["out_dir"], self.data_dict[i]["image"])
pred_array = predict(pred_data, num_evals=config["num_evals"], model=model)
#self.assertIsNotNone(pred_array)
mean = float16(pred_array.mean(axis=0))
save(sub(config["base_file_extension"], config['mean_file_extension'], new_file_name), mean)
save(sub(config["base_file_extension"], config["pred_file_extension"], new_file_name), pred_array)

predict.py at commit 49cba49, under GPL-3.0 · at the source

Overview

Authors: Matthew W Rozak^1,2, James R Mester^1,2, Ahmadreza Attarpour^1,2, Adrienne Dorr², Shruti Patel², Margaret Koletar², Mary E Hill³, Joanne McLaurin^3,4,5, Maged Goubran^1,2,5, Bojana Stefanovic^1,2,5

ORCID iDs: Matthew W Rozak, Ahmadreza Attarpour, Adrienne Dorr, Shruti Patel, Margaret Koletar, Mary E Hill, Maged Goubran, Bojana Stefanovic

Department of Medical Biophysics, University of Toronto, Toronto, Canada
Physical Sciences, Sunnybrook Research Institute, Toronto, Canada
Biological Sciences, Sunnybrook Research Institute, Toronto, Canada
Department of Laboratory Medicine and Pathobiology, University of Toronto, Toronto, Canada
Hurvitz Brain Sciences, Sunnybrook Research Institute, Toronto, Canada

Institutions: University of Toronto (Canada); Sunnybrook Research Institute (Canada)

Journal: eLife, volume 13, article RP95525

Dates: published online 24 March 2026

Type: Research article · Language: English

License: CC BY

Identifiers: DOI 10.7554/elife.95525 · PMID 41873945 · PMCID PMC13012726 · OpenAlex W4393870627

Open access: gold, a free copy (OpenAlex)

Status: code verified (how the code is found and verified)

Categories: histology / microscopy (modality), optical imaging (calcium, voltage, 2-photon) (modality), mouse (organism), rat (organism), stroke (population)

Methods: Preprocessing, Connectivity, Statistics, Machine learning, Graphs, fMRI & imaging

Keywords: Mouse, Rat

MeSH: Brain*, Deep Learning*, Microscopy, Fluorescence, Multiphoton*, Neurovascular Coupling*, Animals, Cerebrovascular Circulation, Mice, Neurons, Optogenetics (* major topic)

Topic: Optical Imaging and Spectroscopy Techniques (Radiology, Nuclear Medicine and Imaging, Medicine), according to OpenAlex

Funding: CIHR (PJT376309, PJT178059, PJT156179); Canada Research Chair Program (CRC-2018-00042, CRC-2021-00374)

Citations: not cited yet (Europe PMC); 102 references in the paper

Abstract

Functional hyperemia is a well-established hallmark of healthy brain function, whereby local brain blood flow adjusts in response to a change in the activity of the surrounding neurons. Although functional hyperemia has been extensively studied at the level of both tissue and individual vessels, vascular network-level coordination remains largely unknown. To bridge this gap, we developed a deep learning-based pipeline that uses two-photon fluorescence microscopy images of cerebral microcirculation to enable automated reconstruction and quantification of the geometric changes across the microvascular network, comprising hundreds of interconnected blood vessels, pre and post-activation of the neighboring neurons. The pipeline’s utility was demonstrated in the Thy1-ChR2 optogenetic mouse model, where we observed network-wide vessel radius changes to depend on the photostimulation intensity, with both dilations and constrictions occurring across the cortical depth, at an average of 16.1±14.3 μm (mean ± SD) away from the most proximal neuron for dilations; and at 21.9±14.6 μm away for constrictions. We observed a significant heterogeneity of the vascular radius changes within vessels, with radius adjustment varying by an average of 24 ± 28% of the resting diameter, likely reflecting the heterogeneity of the distribution of contractile cells on the vessel walls. A graph theory-based network analysis revealed that the assortativity of adjacent blood vessel responses rose by 152 ± 65% at 4.3 mW/mm2 of blue photostimulation vs. the control, with a 4% median increase in the efficiency of the capillary networks during this level of blue photostimulation in relation to the baseline. Interrogating individual vessels is thus not sufficient to predict how the blood flow is modulated in the network. Our pipeline, enables tracking of the microvascular network geometry over time, relating caliber adjustments to vessel wall-associated cells’ state, and mapping network-level flow distribution impairments in experimental models of disease.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repository

Its files are read in the Code ↔ Paper reader above, with 5 matches between paragraphs and lines of code.

AICONSlab/novas3d

License: GPL-3.0

State: the link answers, verified on 30 September 2026

Evidence: files inventoried

Commit: 49cba490403840a820885171e44fa053dde0e8de, 23 March 2026

Languages: Python (6), Jupyter (1), MATLAB (1)

Size: 50 files, 8 scripts

Software Heritage: not archived

Found in: “Data availability”

Holds: README, license file, environment (pyproject.toml, docs/requirements.txt), documentation, 1 notebook

Not found: CITATION.cff, tests, continuous integration

Tools: NumPy (5 files), scikit-image (3 files), SciPy (2 files), ANTs (1 file), Image Processing Toolbox (1 file), Matplotlib (1 file), MONAI (1 file), NetworkX (1 file), NiBabel (1 file), PyTorch (1 file), tifffile (1 file)

Availability: 1 check, the latest on 30 September 2026: the link answers

30 September 2026: the link answers

10 files

Tutorial.ipynb, Jupyter, 669 lines
docs/conf.py, Python, 162 lines
gen_skeletons_warped_single.m, MATLAB, 27 lines
novas3d/__init__.py, Python, 1 line
novas3d/predict.py, Python, 483 lines, 3 matches
novas3d/registration.py, Python, 160 lines
novas3d/utilities.py, Python, 209 lines
novas3d/vessel_graph.py, Python, 697 lines, 2 matches
LICENSE, License, 674 lines
README.md, Text, 36 lines

At the source: github.com/AICONSlab/novas3d

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
8 scripts, each with its path and the digest of its content;
5 matches between paragraphs of the paper and lines of the code (method lexical-v1);
neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data availability

Imaging data used in this paper was deposited in the Federated Research Data Repository (FRDR) and is available at https://doi.org/10.20383/103.01588. The code for the analyses presented in this paper is openly accessible at https://github.com/AICONSlab/novas3d (copy archived at Rozak and Osmann , 2026).

The following dataset was generated:

Rozak M, Mester J, Attarpour A, Dorr A, Patel S, Koletar M, Hill M, McLaurin J, Goubran M, Stefanovic B. 2026. THY1-ChR2-EYFP mouse images used to train and test the NOVAS3D pipeline. Federated Research Data Repository.

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 30 September 2026: the first record

Recorded: type, language, journal, volume, pages, dates, 10 authors, 2 keywords, 9 MeSH terms, 2 funders, 96 references.

Cite

This paper

Rozak, M. W., Mester, J. R., Attarpour, A., Dorr, A., Patel, S., Koletar, M., Hill, M. E., McLaurin, J., Goubran, M., & Stefanovic, B. (2026). A deep learning pipeline for mapping in situ network-level neurovascular coupling in multi-photon fluorescence microscopy. eLife, 13, RP95525. https://doi.org/10.7554/elife.95525

BibTeX

@article{rozak2026deep, author = {Rozak, Matthew W and Mester, James R and Attarpour, Ahmadreza and Dorr, Adrienne and Patel, Shruti and Koletar, Margaret and Hill, Mary E and McLaurin, Joanne and Goubran, Maged and Stefanovic, Bojana}, title = {{A deep learning pipeline for mapping in situ network-level neurovascular coupling in multi-photon fluorescence microscopy}}, journal = {eLife}, year = {2026}, month = mar, volume = {13}, pages = {RP95525}, publisher = {eLife Sciences Publications, Ltd}, issn = {2050-084X}, doi = {10.7554/elife.95525}, url = {https://doi.org/10.7554/elife.95525}, pmid = {41873945}, pmcid = {PMC13012726} }

RIS

TY - JOUR AU - Rozak, Matthew W AU - Mester, James R AU - Attarpour, Ahmadreza AU - Dorr, Adrienne AU - Patel, Shruti AU - Koletar, Margaret AU - Hill, Mary E AU - McLaurin, Joanne AU - Goubran, Maged AU - Stefanovic, Bojana TI - A deep learning pipeline for mapping in situ network-level neurovascular coupling in multi-photon fluorescence microscopy T2 - eLife J2 - eLife PY - 2026 DA - 2026/03/24 VL - 13 SP - RP95525 SN - 2050-084X PB - eLife Sciences Publications, Ltd DO - 10.7554/elife.95525 UR - https://doi.org/10.7554/elife.95525 LA - en ER -

CSL-JSON

{ "id": "10.7554/elife.95525", "type": "article-journal", "title": "A deep learning pipeline for mapping in situ network-level neurovascular coupling in multi-photon fluorescence microscopy", "container-title": "eLife", "author": [ { "family": "Rozak", "given": "Matthew W" }, { "family": "Mester", "given": "James R" }, { "family": "Attarpour", "given": "Ahmadreza" }, { "family": "Dorr", "given": "Adrienne" }, { "family": "Patel", "given": "Shruti" }, { "family": "Koletar", "given": "Margaret" }, { "family": "Hill", "given": "Mary E" }, { "family": "McLaurin", "given": "Joanne" }, { "family": "Goubran", "given": "Maged" }, { "family": "Stefanovic", "given": "Bojana" } ], "container-title-short": "eLife", "volume": "13", "page": "RP95525", "DOI": "10.7554/elife.95525", "PMID": "41873945", "PMCID": "PMC13012726", "ISSN": "2050-084X", "publisher": "eLife Sciences Publications, Ltd", "URL": "https://doi.org/10.7554/elife.95525", "language": "en", "issued": { "date-parts": [ [ 2026, 3, 24 ] ] } }

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1038/s41592-024-02583-1 [code]: A deep learning pipeline for three-dimensional brain-wide mapping of local neuronal ensembles in teravoxel light-sheet microscopy.
Journal: Nature methods
In common: MONAI, PyTorch, NumPy, histology / microscopy, mouse, 5 references, 2 authors
[2] doi:10.3390/biomedicines13010072 [code]: Modeling of Blood Flow Dynamics in Rat Somatosensory Cortex.
Journal: Biomedicines
In common: NetworkX, SciPy, Matplotlib, 1 other tool, rat, 8 references
[3] doi:10.1016/j.crmeth.2023.100436 [code]: Rapid and fully automated blood vasculature analysis in 3D light-sheet image volumes of different organs.
Journal: Cell reports methods
In common: tifffile, NetworkX, scikit-image, 3 other tools, histology / microscopy, mouse, 5 references
[4] doi:10.1242/dev.202703 [code]: Examining the NEUROG2 lineage and associated gene expression in human cortical organoids.
Journal: Development (Cambridge, England)
In common: scikit-image, SciPy, Matplotlib, 1 other tool, 2 authors
[5] doi:10.1073/pnas.2521872123 [code]: Microvascular architecture and physiological fluctuations constrain the control of cerebral microcirculation.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: tifffile, NetworkX, scikit-image, 4 other tools, stroke, histology / microscopy, 3 references
[6] doi:10.1038/s41592-024-02245-2 [code]: Virtual reality-empowered deep-learning analysis of brain cells.
Journal: Nature methods
In common: MONAI, tifffile, scikit-image, 6 other tools, mouse, 2 references
[7] doi:10.1073/pnas.2321021121: Capillary regression leads to sustained local hypoperfusion by inducing constriction of upstream transitional vessels.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: optical imaging (calcium, voltage, 2-photon), stroke, mouse, 7 references
[8] doi:10.3389/fncir.2022.977700 [code]: Igneous: Distributed dense 3D segmentation meshing, neuron skeletonization, and hierarchical downsampling.
Journal: Frontiers in neural circuits
In common: tifffile, NetworkX, scikit-image, 5 other tools, histology / microscopy, 2 references
[9] doi:10.1016/j.crmeth.2026.101473 [code]: AmygdalaGo-BOLT for boundary-aware segmentation of the human amygdala.
Journal: Cell reports methods
In common: MONAI, ANTs, scikit-image, 6 other tools, 1 reference
[10] doi:10.1093/gigascience/giad035 [code]: FriendlyClearMap: an optimized toolkit for mouse brain mapping and analysis.
Journal: GigaScience
In common: tifffile, scikit-image, NiBabel, 5 other tools, histology / microscopy, mouse, 2 references

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Add the badge to the code's README

If you are an author or a maintainer of this paper's code, you can add this badge. It says what OSCR knows of the paper (its code, its validated tracing map) and links the code to this page. Paste one of these snippets under the README's title. Keep the two marks around it, so that the badge can be replaced in place and is never added twice. OSCR changes nothing in your repository.

Markdown

<!-- oscr-badge:start -->
[![OSCR](https://openscicode.org/badge/doi/10.7554/elife.95525.svg)](https://openscicode.org/badge/doi/10.7554/elife.95525)
<!-- oscr-badge:end -->

reStructuredText

.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.7554/elife.95525.svg
   :target: https://openscicode.org/badge/doi/10.7554/elife.95525
   :alt: OSCR

.. oscr-badge:end

HTML

<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.7554/elife.95525"><img src="https://openscicode.org/badge/doi/10.7554/elife.95525.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->

On GitHub, open the README, choose Edit (the pencil), paste the snippet under the title, then "Commit changes".

AICONSlab/novas3d: README.md on GitHub

If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.

Report a mismatch between the code and the paper · Report a code error (signed in)

Reproductions: reports from readers who ran the authors' code and did not get the paper's result, what they ran, with which environment, commit and data.

Report a reproduction failure (signed in)

Versions of its code: the releases of its code tied to a version of this paper (the preprint, the accepted manuscript, the version of record…), each with the tracing map versioned with it.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.