OSCR

A modular and flexible pipeline for intraoperative electrode reconstruction and localization in patients with brain lesions.

Code ↔ Paper

3 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 3 matches
  1. [1] § Materials and methods › Electrode localization and reconstruction ↔ hubconf.py, lines 218–239 · score 0.57 · DPT Large model, MiDaS, pretrained, location, depth, maps
  2. [2] § Materials and methods › Electrode localization and reconstruction ↔ ExampleCode_Intraoperative_Electrode_Localization/example_mainMNIIntraopDeID.m, lines 212–258 · score 0.53 · rigid body, MNI, RAS, MRI, electrodes, localization
  3. [3] § Materials and methods › Electrode localization and reconstruction ↔ run.py, lines 208–277 · score 0.53 · DPT Large, depth maps, camera, alignment, MiDaS, trained

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 435 lines · 13 KB · MIT · 1 match

  1. dependencies = ["torch"]
  3. import torch
  5. from midas.dpt_depth import DPTDepthModel
  6. from midas.midas_net import MidasNet
  7. from midas.midas_net_custom import MidasNet_small
  9. def DPT_BEiT_L_512(pretrained=True, **kwargs):
  10. """ # This docstring shows up in hub.help()
  11. MiDaS DPT_BEiT_L_512 model for monocular depth estimation
  12. pretrained (bool): load pretrained weights into model
  13. """
  15. model = DPTDepthModel(
  16. path=None,
  17. backbone="beitl16_512",
  18. non_negative=True,
  19. )
  21. if pretrained:
  22. checkpoint = (
  23. "https://github.com/isl-org/MiDaS/releases/download/v3_1/dpt_beit_large_512.pt"
  24. )
  25. state_dict = torch.hub.load_state_dict_from_url(
  26. checkpoint, map_location=torch.device('cpu'), progress=True, check_hash=True
  27. )
  28. model.load_state_dict(state_dict)
  30. return model
  32. def DPT_BEiT_L_384(pretrained=True, **kwargs):
  33. """ # This docstring shows up in hub.help()
  34. MiDaS DPT_BEiT_L_384 model for monocular depth estimation
  35. pretrained (bool): load pretrained weights into model
  36. """
  38. model = DPTDepthModel(
  39. path=None,
  40. backbone="beitl16_384",
  41. non_negative=True,
  42. )
  44. if pretrained:
  45. checkpoint = (
  46. "https://github.com/isl-org/MiDaS/releases/download/v3_1/dpt_beit_large_384.pt"
  47. )
  48. state_dict = torch.hub.load_state_dict_from_url(
  49. checkpoint, map_location=torch.device('cpu'), progress=True, check_hash=True
  50. )
  51. model.load_state_dict(state_dict)
  53. return model
  55. def DPT_BEiT_B_384(pretrained=True, **kwargs):
  56. """ # This docstring shows up in hub.help()
  57. MiDaS DPT_BEiT_B_384 model for monocular depth estimation
  58. pretrained (bool): load pretrained weights into model
  59. """
  61. model = DPTDepthModel(
  62. path=None,
  63. backbone="beitb16_384",
  64. non_negative=True,
  65. )
  67. if pretrained:
  68. checkpoint = (
  69. "https://github.com/isl-org/MiDaS/releases/download/v3_1/dpt_beit_base_384.pt"
  70. )
  71. state_dict = torch.hub.load_state_dict_from_url(
  72. checkpoint, map_location=torch.device('cpu'), progress=True, check_hash=True
  73. )
  74. model.load_state_dict(state_dict)
  76. return model
  78. def DPT_SwinV2_L_384(pretrained=True, **kwargs):
  79. """ # This docstring shows up in hub.help()
  80. MiDaS DPT_SwinV2_L_384 model for monocular depth estimation
  81. pretrained (bool): load pretrained weights into model
  82. """
  84. model = DPTDepthModel(
  85. path=None,
  86. backbone="swin2l24_384",
  87. non_negative=True,
  88. )
  90. if pretrained:
  91. checkpoint = (
  92. "https://github.com/isl-org/MiDaS/releases/download/v3_1/dpt_swin2_large_384.pt"
  93. )
  94. state_dict = torch.hub.load_state_dict_from_url(
  95. checkpoint, map_location=torch.device('cpu'), progress=True, check_hash=True
  96. )
  97. model.load_state_dict(state_dict)
  99. return model
  101. def DPT_SwinV2_B_384(pretrained=True, **kwargs):
  102. """ # This docstring shows up in hub.help()
  103. MiDaS DPT_SwinV2_B_384 model for monocular depth estimation
  104. pretrained (bool): load pretrained weights into model
  105. """
  107. model = DPTDepthModel(
  108. path=None,
  109. backbone="swin2b24_384",
  110. non_negative=True,
  111. )
  113. if pretrained:
  114. checkpoint = (
  115. "https://github.com/isl-org/MiDaS/releases/download/v3_1/dpt_swin2_base_384.pt"
  116. )
  117. state_dict = torch.hub.load_state_dict_from_url(
  118. checkpoint, map_location=torch.device('cpu'), progress=True, check_hash=True
  119. )
  120. model.load_state_dict(state_dict)
  122. return model
  124. def DPT_SwinV2_T_256(pretrained=True, **kwargs):
  125. """ # This docstring shows up in hub.help()
  126. MiDaS DPT_SwinV2_T_256 model for monocular depth estimation
  127. pretrained (bool): load pretrained weights into model
  128. """
  130. model = DPTDepthModel(
  131. path=None,
  132. backbone="swin2t16_256",
  133. non_negative=True,
  134. )
  136. if pretrained:
  137. checkpoint = (
  138. "https://github.com/isl-org/MiDaS/releases/download/v3_1/dpt_swin2_tiny_256.pt"
  139. )
  140. state_dict = torch.hub.load_state_dict_from_url(
  141. checkpoint, map_location=torch.device('cpu'), progress=True, check_hash=True
  142. )
  143. model.load_state_dict(state_dict)
  145. return model
  147. def DPT_Swin_L_384(pretrained=True, **kwargs):
  148. """ # This docstring shows up in hub.help()
  149. MiDaS DPT_Swin_L_384 model for monocular depth estimation
  150. pretrained (bool): load pretrained weights into model
  151. """
  153. model = DPTDepthModel(
  154. path=None,
  155. backbone="swinl12_384",
  156. non_negative=True,
  157. )
  159. if pretrained:
  160. checkpoint = (
  161. "https://github.com/isl-org/MiDaS/releases/download/v3_1/dpt_swin_large_384.pt"
  162. )
  163. state_dict = torch.hub.load_state_dict_from_url(
  164. checkpoint, map_location=torch.device('cpu'), progress=True, check_hash=True
  165. )
  166. model.load_state_dict(state_dict)
  168. return model
  170. def DPT_Next_ViT_L_384(pretrained=True, **kwargs):
  171. """ # This docstring shows up in hub.help()
  172. MiDaS DPT_Next_ViT_L_384 model for monocular depth estimation
  173. pretrained (bool): load pretrained weights into model
  174. """
  176. model = DPTDepthModel(
  177. path=None,
  178. backbone="next_vit_large_6m",
  179. non_negative=True,
  180. )
  182. if pretrained:
  183. checkpoint = (
  184. "https://github.com/isl-org/MiDaS/releases/download/v3_1/dpt_next_vit_large_384.pt"
  185. )
  186. state_dict = torch.hub.load_state_dict_from_url(
  187. checkpoint, map_location=torch.device('cpu'), progress=True, check_hash=True
  188. )
  189. model.load_state_dict(state_dict)
  191. return model
  193. def DPT_LeViT_224(pretrained=True, **kwargs):
  194. """ # This docstring shows up in hub.help()
  195. MiDaS DPT_LeViT_224 model for monocular depth estimation
  196. pretrained (bool): load pretrained weights into model
  197. """
  199. model = DPTDepthModel(
  200. path=None,
  201. backbone="levit_384",
  202. non_negative=True,
  203. head_features_1=64,
  204. head_features_2=8,
  205. )
  207. if pretrained:
  208. checkpoint = (
  209. "https://github.com/isl-org/MiDaS/releases/download/v3_1/dpt_levit_224.pt"
  210. )
  211. state_dict = torch.hub.load_state_dict_from_url(
  212. checkpoint, map_location=torch.device('cpu'), progress=True, check_hash=True
  213. )
  214. model.load_state_dict(state_dict)
  216. return model
  218. def DPT_Large(pretrained=True, **kwargs):
  219. """ # This docstring shows up in hub.help()
  220. MiDaS DPT-Large model for monocular depth estimation
  221. pretrained (bool): load pretrained weights into model
  222. """
  224. model = DPTDepthModel(
  225. path=None,
  226. backbone="vitl16_384",
  227. non_negative=True,
  228. )
  230. if pretrained:
  231. checkpoint = (
  232. "https://github.com/isl-org/MiDaS/releases/download/v3/dpt_large_384.pt"
  233. )
  234. state_dict = torch.hub.load_state_dict_from_url(
  235. checkpoint, map_location=torch.device('cpu'), progress=True, check_hash=True
  236. )
  237. model.load_state_dict(state_dict)
  239. return model
  241. def DPT_Hybrid(pretrained=True, **kwargs):
  242. """ # This docstring shows up in hub.help()
  243. MiDaS DPT-Hybrid model for monocular depth estimation
  244. pretrained (bool): load pretrained weights into model
  245. """
  247. model = DPTDepthModel(
  248. path=None,
  249. backbone="vitb_rn50_384",
  250. non_negative=True,
  251. )
  253. if pretrained:
  254. checkpoint = (
  255. "https://github.com/isl-org/MiDaS/releases/download/v3/dpt_hybrid_384.pt"
  256. )
  257. state_dict = torch.hub.load_state_dict_from_url(
  258. checkpoint, map_location=torch.device('cpu'), progress=True, check_hash=True
  259. )
  260. model.load_state_dict(state_dict)
  262. return model
  264. def MiDaS(pretrained=True, **kwargs):
  265. """ # This docstring shows up in hub.help()
  266. MiDaS v2.1 model for monocular depth estimation
  267. pretrained (bool): load pretrained weights into model
  268. """
  270. model = MidasNet()
  272. if pretrained:
  273. checkpoint = (
  274. "https://github.com/isl-org/MiDaS/releases/download/v2_1/midas_v21_384.pt"
  275. )
  276. state_dict = torch.hub.load_state_dict_from_url(
  277. checkpoint, map_location=torch.device('cpu'), progress=True, check_hash=True
  278. )
  279. model.load_state_dict(state_dict)
  281. return model
  283. def MiDaS_small(pretrained=True, **kwargs):
  284. """ # This docstring shows up in hub.help()
  285. MiDaS v2.1 small model for monocular depth estimation on resource-constrained devices
  286. pretrained (bool): load pretrained weights into model
  287. """
  289. model = MidasNet_small(None, features=64, backbone="efficientnet_lite3", exportable=True, non_negative=True, blocks={'expand': True})
  291. if pretrained:
  292. checkpoint = (
  293. "https://github.com/isl-org/MiDaS/releases/download/v2_1/midas_v21_small_256.pt"
  294. )
  295. state_dict = torch.hub.load_state_dict_from_url(
  296. checkpoint, map_location=torch.device('cpu'), progress=True, check_hash=True
  297. )
  298. model.load_state_dict(state_dict)
  300. return model
  303. def transforms():
  304. import cv2
  305. from torchvision.transforms import Compose
  306. from midas.transforms import Resize, NormalizeImage, PrepareForNet
  307. from midas import transforms
  309. transforms.default_transform = Compose(
  310. [
  311. lambda img: {"image": img / 255.0},
  312. Resize(
  313. 384,
  314. 384,
  315. resize_target=None,
  316. keep_aspect_ratio=True,
  317. ensure_multiple_of=32,
  318. resize_method="upper_bound",
  319. image_interpolation_method=cv2.INTER_CUBIC,
  320. ),
  321. NormalizeImage(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
  322. PrepareForNet(),
  323. lambda sample: torch.from_numpy(sample["image"]).unsqueeze(0),
  324. ]
  325. )
  327. transforms.small_transform = Compose(
  328. [
  329. lambda img: {"image": img / 255.0},
  330. Resize(
  331. 256,
  332. 256,
  333. resize_target=None,
  334. keep_aspect_ratio=True,
  335. ensure_multiple_of=32,
  336. resize_method="upper_bound",
  337. image_interpolation_method=cv2.INTER_CUBIC,
  338. ),
  339. NormalizeImage(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
  340. PrepareForNet(),
  341. lambda sample: torch.from_numpy(sample["image"]).unsqueeze(0),
  342. ]
  343. )
  345. transforms.dpt_transform = Compose(
  346. [
  347. lambda img: {"image": img / 255.0},
  348. Resize(
  349. 384,
  350. 384,
  351. resize_target=None,
  352. keep_aspect_ratio=True,
  353. ensure_multiple_of=32,
  354. resize_method="minimal",
  355. image_interpolation_method=cv2.INTER_CUBIC,
  356. ),
  357. NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
  358. PrepareForNet(),
  359. lambda sample: torch.from_numpy(sample["image"]).unsqueeze(0),
  360. ]
  361. )
  363. transforms.beit512_transform = Compose(
  364. [
  365. lambda img: {"image": img / 255.0},
  366. Resize(
  367. 512,
  368. 512,
  369. resize_target=None,
  370. keep_aspect_ratio=True,
  371. ensure_multiple_of=32,
  372. resize_method="minimal",
  373. image_interpolation_method=cv2.INTER_CUBIC,
  374. ),
  375. NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
  376. PrepareForNet(),
  377. lambda sample: torch.from_numpy(sample["image"]).unsqueeze(0),
  378. ]
  379. )
  381. transforms.swin384_transform = Compose(
  382. [
  383. lambda img: {"image": img / 255.0},
  384. Resize(
  385. 384,
  386. 384,
  387. resize_target=None,
  388. keep_aspect_ratio=False,
  389. ensure_multiple_of=32,
  390. resize_method="minimal",
  391. image_interpolation_method=cv2.INTER_CUBIC,
  392. ),
  393. NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
  394. PrepareForNet(),
  395. lambda sample: torch.from_numpy(sample["image"]).unsqueeze(0),
  396. ]
  397. )
  399. transforms.swin256_transform = Compose(
  400. [
  401. lambda img: {"image": img / 255.0},
  402. Resize(
  403. 256,
  404. 256,
  405. resize_target=None,
  406. keep_aspect_ratio=False,
  407. ensure_multiple_of=32,
  408. resize_method="minimal",
  409. image_interpolation_method=cv2.INTER_CUBIC,
  410. ),
  411. NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
  412. PrepareForNet(),
  413. lambda sample: torch.from_numpy(sample["image"]).unsqueeze(0),
  414. ]
  415. )
  417. transforms.levit_transform = Compose(
  418. [
  419. lambda img: {"image": img / 255.0},
  420. Resize(
  421. 224,
  422. 224,
  423. resize_target=None,
  424. keep_aspect_ratio=False,
  425. ensure_multiple_of=32,
  426. resize_method="minimal",
  427. image_interpolation_method=cv2.INTER_CUBIC,
  428. ),
  429. NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
  430. PrepareForNet(),
  431. lambda sample: torch.from_numpy(sample["image"]).unsqueeze(0),
  432. ]
  433. )
  435. return transforms

hubconf.py at commit 4545977, under MIT · at the source

Overview

Authors: Haziq Rabbani1,2,3, Ipsita Das2,3, Ayan S Mandal2,3, Thomas Nelson4, Peter Hadar2,3, Brian Hsueh2,5, Roberto Ciordia2, Brian F Coughlin2,3, Emory Peng2,3, Daniel R Cleary6, Kelly L Collins6, Ahmed M T Raslan6, Ziv M Williams5, Bryan D Choi5, Garth Rees Cosgrove5, Shadi A Dayeh7, Pamela S Jones5, Harmanpreet K Tiwana2, Gavin P Dunn5, R Mark Richardson5, Wenya Linda Bi5, Steven Tobochnik8, Sydney S Cash2,3, Daniel P Cahill5, Angelique C Paulk2,3
ORCID iDs: Kelly L Collins
  1. College of Medicine, Northeast Ohio Medical University, Rootstown, OH, United States
  2. Department of Neurology, Mass General Brigham, Boston, MA, United States
  3. Center for Neurotechnology and Neurorecovery, Boston, MA, United States
  4. Division of Neuro-Oncology, Department of Neurosurgery, University of California, San Francisco, San Francisco, CA, United States
  5. Department of Neurosurgery, Mass General Brigham, Boston, MA, United States
  6. Department of Neurosurgery, Oregon Health State University, Portland, OR, United States
  7. Department of Neurosurgery, University of California, San Diego, La Jolla, CA, United States
  8. Center for Neuro-Oncology, Department of Medical Oncology, Dana-Farber Cancer Institute, Boston, MA, United States
Institutions: Mass General Brigham (United States); Northeast Ohio Medical University (United States); University of California, San Francisco (United States); University of California San Diego (United States); Center for Neuro-Oncology (United States); Dana-Farber Cancer Institute (United States)
Journal: Frontiers in neural circuits, volume 20, article 1814667
Dates: received 21 February 2026; accepted 19 May 2026; published online 10 June 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.3389/fncir.2026.1814667 · PMID 42358667 · PMCID PMC13290761 · OpenAlex W7164175428
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality), intracranial EEG (iEEG / ECoG / SEEG) (modality), human (organism), other condition (population), epilepsy (population), methods / tools (subfield)
Keywords: electrophysiology, epilepsy, human, imaging, intraoperative, parcellation, tumor
MeSH: Brain*, Brain Mapping*, Electrocorticography*, Electrodes, Implanted*, Image Processing, Computer-Assisted*, Intraoperative Neurophysiological Monitoring*, Brain Neoplasms, Female, Humans, Magnetic Resonance Imaging (* major topic)
Topic: Neuroscience and Neural Engineering (Cellular and Molecular Neuroscience, Neuroscience), according to OpenAlex
Funding: NIBIB NIH HHS (DP2 EB029757); NINDS NIH HHS (K24 NS088568, R01 NS134410, R01 NS123655, UG3 NS123723); NIMH NIH HHS (F32 MH120886)
Citations: not cited yet (Europe PMC); 76 references in the paper

Abstract

Intraoperative intracranial electrophysiological recordings provide unique access to human cortical dynamics but remain difficult to translate across patients due to inconsistent localization of transient surface electrodes. Unlike chronic implantations, intraoperative electrodes are placed transiently, rarely visible on imaging, and often inconsistently documented. We present an open-source imaging pipeline, ALIGNER (Advanced Localization and Imaging Guidance for Neurosurgical Electrode Recording), designed to reconstruct intraoperative surface electrode array placements and quantitatively map neural activity to individualized anatomical and pathological substrates. By enabling anatomical localization of these electrodes, this framework supports systematic analysis of spatial gradients in neural activity relative to pathological tissue. We developed a multimodal reconstruction framework integrating pre- and postoperative MRI and CT, cortical surface modeling, semi-automated pathology segmentation, intraoperative photographs or videos when available, and physics-based electrode modeling. To improve robustness in cases with distorted anatomy, artificial intelligence tools such as SynthSR were used to enable reliable cortical surface reconstruction prior to FreeSurfer processing. A monocular depth-estimation network was incorporated to constrain electrode placement in conjunction with Blender cloth-physics simulation when photographic images were available, while atlas- and note-guided inference supported reconstruction otherwise. The pipeline was applied to 38 neurosurgical patients across drug-resistant epilepsy resection (n = 24), malformation (n = 1), brain tumor (n = 11), and deep brain stimulation (n = 2) cases, achieving some type of reconstruction and electrode localization in all participants. By exporting electrode coordinates for quantitative spatial analyses, including distance-based mapping relative to lesions and resection cavities, ALIGNER enables anatomically grounded and reproducible analysis of intraoperative electrophysiology. This open-source framework provides foundational infrastructure for cancer neuroscience studies of tumor–neuron interactions and establishes a scalable platform for future neurostimulation, implantable neurodevice, and brain–computer interface applications requiring precise anatomical localization.

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

Repositories

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

Center-For-Neurotechnology/BrainInterface3D

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 3dbaf34b002eef7625f5e872779cc3725d73673b, 18 May 2026
Languages: MATLAB (2), Python (2)
Size: 13 files, 4 scripts
Software Heritage: not archived
Found in: “Data availability statement”
Holds: README, license file, environment (ExampleCode_Intraoperative_Electrode_Localization/requirements_Blender_csvExport.txt, ExampleCode_Intraoperative_Electrode_Localization/requirements_pymeshlab.txt)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: FieldTrip (1 file), GIfTI library for MATLAB (1 file), NumPy (1 file), pandas (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
6 files
At the source: github.com/Center-For-Neurotechnology/BrainInterface3D

PerkLab/SlicerFreeSurfer

License: BSD-3-Clause
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: fe78ea4b5516d1ed97cf629890f24bd52af585f1, 23 July 2026
Languages: C/C++ (28), Python (1)
Size: 97 files, 29 scripts
Software Heritage: not archived
Found in: the text
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NiBabel (1 file), NumPy (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
31 files
At the source: github.com/PerkLab/SlicerFreeSurfer

isl-org/MiDaS

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 454597711a62eabcbf7d1e89f3fb9f569051ac9b, 23 August 2024
Languages: Python (27), Java (22), Shell (8), C++ (1)
Size: 191 files, 58 scripts
Software Heritage: not archived
Found in: the text
Holds: README, license file, environment (Dockerfile, environment.yaml)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: PyTorch (16 files), OpenCV (14 files), NumPy (13 files), TensorFlow (2 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
60 files
At the source: github.com/isl-org/MiDaS

cnr-isti-vclab/PyMeshLab

License: GPL-3.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 9c30334547750bcbe7126278b16739349643d04b, 3 February 2026
Languages: Python (34), C/C++ (31), C++ (26), Shell (11), MATLAB (1)
Size: 196 files, 103 scripts
Software Heritage: not archived
Found in: “Data availability statement”
Holds: README, license file, environment (requirements.txt, setup.py, .devcontainer/Dockerfile_aarch64, .devcontainer/Dockerfile_x86_64, pymeshlab/setup.cfg, .devcontainer/build_wheel_3_10_aarch64/devcontainer.json, .devcontainer/build_wheel_3_10_x86_64/devcontainer.json, .devcontainer/build_wheel_3_11_aarch64/devcontainer.json, .devcontainer/build_wheel_3_11_x86_64/devcontainer.json, .devcontainer/build_wheel_3_12_aarch64/devcontainer.json, .devcontainer/build_wheel_3_12_x86_64/devcontainer.json, .devcontainer/build_wheel_3_13_aarch64/devcontainer.json), tests, continuous integration, documentation, 1 notebook
Not found: CITATION.cff
Tools: NumPy (5 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
105 files
At the source: github.com/cnr-isti-vclab/PyMeshLab

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:

  • 4 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 194 scripts, each with its path and the digest of its content;
  • 3 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 statement

The data that support the findings of this study are available from the corresponding author upon reasonable request and agreement to only receive de-identified data. Documentation and code including commands for different packages are available at the main repository (https://github.com/Center-For-Neurotechnology/BrainInterface3D). Electrode tracking over the cortical surface involved 3D reconstruction of the brain surface and segmentation including vessels using 3Dslicer (https://www.slicer.org/) (Kikinis and Pieper, 2011; Fedorov et al., 2012), Freesurfer (https://surfer.nmr.mgh.harvard.edu/) (Dale et al., 1999; Fischl and Dale, 2000; Fischl et al., 2001; Desikan et al., 2006; Dykstra et al., 2012; Felsenstein and Peled, 2017; Billot et al., 2021, 2022; Iglesias et al., 2021; Soper et al., 2022, 2023), and the Human Connectome Project (HCP) pipeline (https://github.com/Washington-University/HCPpipelines) (Glasser et al., 2013, 2016; Elam et al., 2021). The segmentations and surface reconstructions along with the skull was imported into Blender (https://www.blender.org/) (Community, 2018) and electrode locations were exported using custom python code. Geodesic distance measures were made possible with pymeshlab (https://github.com/cnr-isti-vclab/PyMeshLab).

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, 27 September 2026: the first record

Recorded: type, language, journal, volume, pages, dates, 25 authors, 7 keywords, 10 MeSH terms, 3 funders, 70 references.

Cite

This paper

Rabbani, H., Das, I., Mandal, A. S., Nelson, T., Hadar, P., Hsueh, B., Ciordia, R., Coughlin, B. F., Peng, E., Cleary, D. R., Collins, K. L., Raslan, A. M. T., Williams, Z. M., Choi, B. D., Cosgrove, G. R., Dayeh, S. A., Jones, P. S., Tiwana, H. K., Dunn, G. P., . . . Paulk, A. C. (2026). A modular and flexible pipeline for intraoperative electrode reconstruction and localization in patients with brain lesions. Frontiers in neural circuits, 20, 1814667. https://doi.org/10.3389/fncir.2026.1814667

BibTeX

@article{rabbani2026modular,
author = {Rabbani, Haziq and Das, Ipsita and Mandal, Ayan S and Nelson, Thomas and Hadar, Peter and Hsueh, Brian and Ciordia, Roberto and Coughlin, Brian F and Peng, Emory and Cleary, Daniel R and Collins, Kelly L and Raslan, Ahmed M T and Williams, Ziv M and Choi, Bryan D and Cosgrove, Garth Rees and Dayeh, Shadi A and Jones, Pamela S and Tiwana, Harmanpreet K and Dunn, Gavin P and Richardson, R Mark and Bi, Wenya Linda and Tobochnik, Steven and Cash, Sydney S and Cahill, Daniel P and Paulk, Angelique C},
title = {{A modular and flexible pipeline for intraoperative electrode reconstruction and localization in patients with brain lesions}},
journal = {Frontiers in neural circuits},
year = {2026},
month = jun,
volume = {20},
pages = {1814667},
publisher = {Frontiers Media SA},
issn = {1662-5110},
doi = {10.3389/fncir.2026.1814667},
url = {https://doi.org/10.3389/fncir.2026.1814667},
pmid = {42358667},
pmcid = {PMC13290761}
}

RIS

TY - JOUR
AU - Rabbani, Haziq
AU - Das, Ipsita
AU - Mandal, Ayan S
AU - Nelson, Thomas
AU - Hadar, Peter
AU - Hsueh, Brian
AU - Ciordia, Roberto
AU - Coughlin, Brian F
AU - Peng, Emory
AU - Cleary, Daniel R
AU - Collins, Kelly L
AU - Raslan, Ahmed M T
AU - Williams, Ziv M
AU - Choi, Bryan D
AU - Cosgrove, Garth Rees
AU - Dayeh, Shadi A
AU - Jones, Pamela S
AU - Tiwana, Harmanpreet K
AU - Dunn, Gavin P
AU - Richardson, R Mark
AU - Bi, Wenya Linda
AU - Tobochnik, Steven
AU - Cash, Sydney S
AU - Cahill, Daniel P
AU - Paulk, Angelique C
TI - A modular and flexible pipeline for intraoperative electrode reconstruction and localization in patients with brain lesions
T2 - Frontiers in neural circuits
J2 - Front Neural Circuits
PY - 2026
DA - 2026/06/10
VL - 20
SP - 1814667
SN - 1662-5110
PB - Frontiers Media SA
DO - 10.3389/fncir.2026.1814667
UR - https://doi.org/10.3389/fncir.2026.1814667
LA - en
ER -

CSL-JSON

{
"id": "10.3389/fncir.2026.1814667",
"type": "article-journal",
"title": "A modular and flexible pipeline for intraoperative electrode reconstruction and localization in patients with brain lesions",
"container-title": "Frontiers in neural circuits",
"author": [
{
"family": "Rabbani",
"given": "Haziq"
},
{
"family": "Das",
"given": "Ipsita"
},
{
"family": "Mandal",
"given": "Ayan S"
},
{
"family": "Nelson",
"given": "Thomas"
},
{
"family": "Hadar",
"given": "Peter"
},
{
"family": "Hsueh",
"given": "Brian"
},
{
"family": "Ciordia",
"given": "Roberto"
},
{
"family": "Coughlin",
"given": "Brian F"
},
{
"family": "Peng",
"given": "Emory"
},
{
"family": "Cleary",
"given": "Daniel R"
},
{
"family": "Collins",
"given": "Kelly L"
},
{
"family": "Raslan",
"given": "Ahmed M T"
},
{
"family": "Williams",
"given": "Ziv M"
},
{
"family": "Choi",
"given": "Bryan D"
},
{
"family": "Cosgrove",
"given": "Garth Rees"
},
{
"family": "Dayeh",
"given": "Shadi A"
},
{
"family": "Jones",
"given": "Pamela S"
},
{
"family": "Tiwana",
"given": "Harmanpreet K"
},
{
"family": "Dunn",
"given": "Gavin P"
},
{
"family": "Richardson",
"given": "R Mark"
},
{
"family": "Bi",
"given": "Wenya Linda"
},
{
"family": "Tobochnik",
"given": "Steven"
},
{
"family": "Cash",
"given": "Sydney S"
},
{
"family": "Cahill",
"given": "Daniel P"
},
{
"family": "Paulk",
"given": "Angelique C"
}
],
"container-title-short": "Front Neural Circuits",
"volume": "20",
"page": "1814667",
"DOI": "10.3389/fncir.2026.1814667",
"PMID": "42358667",
"PMCID": "PMC13290761",
"ISSN": "1662-5110",
"publisher": "Frontiers Media SA",
"URL": "https://doi.org/10.3389/fncir.2026.1814667",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
10
]
]
}
}

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/s41586-026-10631-3 [code]
A prognostic human brain network for diffuse midline glioma.
Journal: Nature
In common: GIfTI library for MATLAB, FieldTrip, TensorFlow, 3 other tools, other condition, 4 references
[2] doi:10.3389/frai.2026.1771088 [code]
Few-shot deployment of pretrained MRI transformers in brain imaging tasks.
Journal: Frontiers in artificial intelligence
In common: OpenCV, NiBabel, PyTorch, 2 other tools, methods / tools, structural MRI / diffusion, 5 references
[3] doi:10.1002/advs.76596 [code]
DDSurfer: A Weakly-Supervised Dual-Stream Deep Learning Framework for Cortical Surface Reconstruction From Diffusion MRI.
Journal: Advanced science (Weinheim, Baden-Wurttemberg, Germany)
In common: NiBabel, PyTorch, pandas, 1 other tool, methods / tools, structural MRI / diffusion, 5 references
[4] doi:10.1038/s41467-026-76011-7 [code]
Human cortex organizes dynamic co-fluctuations along the sensorimotor-association axis.
Journal: Nature communications
In common: GIfTI library for MATLAB, FieldTrip, OpenCV, 3 other tools, 2 references
[5] doi:10.1038/s41598-026-55397-w [code]
Fast surface reconstruction of human brain MRI: benchmarking deep-learning based morphometry tools.
Journal: Scientific reports
In common: NiBabel, PyTorch, pandas, 1 other tool, methods / tools, structural MRI / diffusion, 5 references
[6] doi:10.1038/s41586-026-10448-0 [code]
Plasticity and language in the anaesthetized human hippocampus.
Journal: Nature
In common: TensorFlow, PyTorch, NumPy, 4 references
[7] doi:10.1002/alz.71649 [code]
Postmortem brain MRI reveals differential associations of subcortical and limbic volumes with cortical thinning and neurodegenerative pathologies.
Journal: Alzheimer's & dementia : the journal of the Alzheimer's Association
In common: OpenCV, NiBabel, PyTorch, 2 other tools, structural MRI / diffusion, other condition, 3 references
[8] doi:10.1016/j.crmeth.2026.101473 [code]
AmygdalaGo-BOLT for boundary-aware segmentation of the human amygdala.
Journal: Cell reports methods
In common: GIfTI library for MATLAB, FieldTrip, OpenCV, 3 other tools, methods / tools, structural MRI / diffusion
[9] doi:10.1162/imag.a.1183 [code]
Learning-based segmentation of diffusion-weighted MR images with arbitrary <i>q</i>-space samplings.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: TensorFlow, NiBabel, PyTorch, 2 other tools, methods / tools, structural MRI / diffusion, 3 references
[10] doi:10.1016/j.neuroimage.2026.122171 [code]
A conserved node degree-based backbone and flexible hub organization of brain connectome during naturalistic movie watching.
Journal: NeuroImage
In common: GIfTI library for MATLAB, FieldTrip, NiBabel, 2 other tools, methods / tools, 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.

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: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

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