OSCR

Multifiber Array-Based Photometry System for Multiregional Functional Mapping in the Mouse Brain.

Code ↔ Paper

The paper beside its authors' code: matches between them have not been computed for this paper yet.

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 · 521 lines · 20 KB · GPL-3.0

  1. import nrrd
  2. import numpy as np
  3. import matplotlib.pyplot as plt
  4. from matplotlib.widgets import Slider, Button, TextBox, RadioButtons
  5. from matplotlib.colors import ListedColormap, Normalize
  6. import json
  8. def load_annotation(filepath):
  9. """Load the NRRD annotation file"""
  10. data, header = nrrd.read(filepath)
  11. return data, header
  13. def load_structure_tree(filepath):
  14. """Load the structure tree JSON file and create ID to name mapping"""
  15. with open(filepath, 'r') as f:
  16. data = json.load(f)
  18. # Create a mapping from structure ID to structure info
  19. id_to_info = {}
  21. def traverse_tree(node):
  22. """Recursively traverse the structure tree"""
  23. structure_id = node.get('id')
  24. name = node.get('name', 'Unknown')
  25. acronym = node.get('acronym', '')
  27. if structure_id is not None:
  28. id_to_info[structure_id] = {
  29. 'name': name,
  30. 'acronym': acronym,
  31. 'color_hex': node.get('color_hex_triplet', 'FFFFFF')
  32. }
  34. # Process children
  35. if 'children' in node:
  36. for child in node['children']:
  37. traverse_tree(child)
  39. # Handle different JSON structures
  40. if isinstance(data, dict):
  41. # Check if there's a 'msg' key (common in Allen Institute files)
  42. if 'msg' in data:
  43. root_nodes = data['msg']
  44. else:
  45. root_nodes = [data]
  46. elif isinstance(data, list):
  47. root_nodes = data
  48. else:
  49. root_nodes = [data]
  51. # Traverse all root nodes
  52. for root in root_nodes:
  53. traverse_tree(root)
  55. return id_to_info
  57. def create_color_mapped_image(slice_data, structure_info):
  58. """Create RGB image from structure IDs using their defined colors"""
  59. # Create RGB image
  60. height, width = slice_data.shape
  61. rgb_image = np.zeros((height, width, 3), dtype=np.uint8)
  63. for i in range(height):
  64. for j in range(width):
  65. struct_id = int(slice_data[i, j])
  66. if struct_id in structure_info and struct_id != 0:
  67. hex_color = structure_info[struct_id]['color_hex']
  68. # Convert hex to RGB
  69. r = int(hex_color[0:2], 16)
  70. g = int(hex_color[2:4], 16)
  71. b = int(hex_color[4:6], 16)
  72. rgb_image[i, j] = [r, g, b]
  73. else:
  74. # Black for background or unknown
  75. rgb_image[i, j] = [0, 0, 0]
  77. return rgb_image
  79. def interactive_viewer_advanced(annotation_data, structure_info):
  80. """
  81. Advanced interactive viewer with:
  82. - Slice navigation (slider + mouse wheel)
  83. - Colorbar
  84. - Adjustable color range (slider + manual input)
  85. - Axis switching
  86. - Rotation
  87. - Zoom and Pan
  88. - Structure name display
  89. - Color mode selection (ID vs Structure colors)
  90. """
  91. # Create figure and axis
  92. fig = plt.figure(figsize=(16, 10))
  94. # Main image axis
  95. ax_img = plt.axes([0.1, 0.30, 0.62, 0.60])
  97. # Colorbar axis
  98. ax_cbar = plt.axes([0.74, 0.30, 0.02, 0.60])
  100. # Info panel axis (for displaying structure details)
  101. ax_info = plt.axes([0.78, 0.65, 0.20, 0.25])
  102. ax_info.axis('off')
  104. # Radio buttons for color mode
  105. ax_radio = plt.axes([0.78, 0.92, 0.15, 0.07])
  107. # Slider axes
  108. ax_slice = plt.axes([0.1, 0.20, 0.62, 0.03])
  109. ax_vmin = plt.axes([0.1, 0.15, 0.62, 0.03])
  110. ax_vmax = plt.axes([0.1, 0.10, 0.62, 0.03])
  112. # Text box axes for manual input
  113. ax_text_vmin = plt.axes([0.1, 0.05, 0.08, 0.03])
  114. ax_text_vmax = plt.axes([0.22, 0.05, 0.08, 0.03])
  116. # Button axes for switching views
  117. ax_btn_coronal = plt.axes([0.78, 0.57, 0.08, 0.04])
  118. ax_btn_sagittal = plt.axes([0.87, 0.57, 0.08, 0.04])
  119. ax_btn_axial = plt.axes([0.78, 0.52, 0.08, 0.04])
  121. # Button axes for rotation
  122. ax_btn_rot_ccw = plt.axes([0.78, 0.45, 0.08, 0.04])
  123. ax_btn_rot_cw = plt.axes([0.87, 0.45, 0.08, 0.04])
  125. # Button axes for zoom
  126. ax_btn_zoom_in = plt.axes([0.78, 0.38, 0.08, 0.04])
  127. ax_btn_zoom_out = plt.axes([0.87, 0.38, 0.08, 0.04])
  129. # Other buttons
  130. ax_btn_reset = plt.axes([0.78, 0.31, 0.08, 0.04])
  131. ax_btn_apply = plt.axes([0.34, 0.05, 0.06, 0.03])
  132. ax_btn_reset_view = plt.axes([0.87, 0.31, 0.08, 0.04])
  134. # Initialize parameters
  135. current_axis = [0] # 0=coronal, 1=sagittal, 2=axial
  136. rotation_angle = [0] # Current rotation angle in degrees
  137. zoom_level = [1.0] # Current zoom level
  138. current_slice_idx = [annotation_data.shape[0] // 2] # Store current slice index
  139. color_mode = ['by_id'] # 'by_id' or 'by_structure'
  141. # Get initial min/max values
  142. data_min = float(np.min(annotation_data))
  143. data_max = float(np.max(annotation_data))
  145. axis_names = ['Coronal', 'Sagittal', 'Axial']
  147. # Create function to get slice data
  148. def get_slice_data(slice_idx=None, axis=None, rotation=None):
  149. """Get current slice data based on axis and rotation"""
  150. if slice_idx is None:
  151. slice_idx = current_slice_idx[0]
  152. if axis is None:
  153. axis = current_axis[0]
  154. if rotation is None:
  155. rotation = rotation_angle[0]
  157. slice_idx = int(slice_idx)
  159. if axis == 0:
  160. slice_data = annotation_data[slice_idx, :, :].T
  161. elif axis == 1:
  162. slice_data = annotation_data[:, slice_idx, :].T
  163. else:
  164. slice_data = annotation_data[:, :, slice_idx].T
  166. # Apply rotation
  167. k = rotation // 90 # Number of 90-degree rotations
  168. if k != 0:
  169. slice_data = np.rot90(slice_data, k)
  171. return slice_data
  173. # Create initial image
  174. initial_slice = get_slice_data()
  176. # Display image (initially by ID)
  177. img = ax_img.imshow(initial_slice, cmap='nipy_spectral', origin='lower',
  178. vmin=data_min, vmax=data_max)
  179. ax_img.set_title(f'{axis_names[current_axis[0]]} Slice {current_slice_idx[0]} (Rotation: {rotation_angle[0]}°) - Color by ID',
  180. fontsize=14, fontweight='bold')
  181. ax_img.axis('on')
  183. # Add colorbar
  184. cbar = plt.colorbar(img, cax=ax_cbar)
  185. cbar.set_label('Structure ID', rotation=270, labelpad=20, fontsize=12)
  187. # Info panel text
  188. info_text = ax_info.text(0.05, 0.95, 'Hover over image\nfor structure info',
  189. transform=ax_info.transAxes,
  190. fontsize=10, verticalalignment='top',
  191. family='monospace',
  192. bbox=dict(boxstyle='round', facecolor='lightblue', alpha=0.8))
  194. # Create radio buttons for color mode
  195. radio = RadioButtons(ax_radio, ('Color by ID', 'Color by Structure'))
  197. # Create sliders
  198. slider_slice = Slider(ax_slice, 'Slice', 0, annotation_data.shape[current_axis[0]]-1,
  199. valinit=current_slice_idx[0], valstep=1)
  200. slider_vmin = Slider(ax_vmin, 'Min ID', data_min, data_max,
  201. valinit=data_min, valstep=1)
  202. slider_vmax = Slider(ax_vmax, 'Max ID', data_min, data_max,
  203. valinit=data_max, valstep=1)
  205. # Create text boxes for manual input
  206. text_box_vmin = TextBox(ax_text_vmin, 'Min:', initial=str(int(data_min)))
  207. text_box_vmax = TextBox(ax_text_vmax, 'Max:', initial=str(int(data_max)))
  209. # Create buttons
  210. btn_coronal = Button(ax_btn_coronal, 'Coronal')
  211. btn_sagittal = Button(ax_btn_sagittal, 'Sagittal')
  212. btn_axial = Button(ax_btn_axial, 'Axial')
  213. btn_rot_ccw = Button(ax_btn_rot_ccw, '↺ 90°')
  214. btn_rot_cw = Button(ax_btn_rot_cw, '↻ 90°')
  215. btn_zoom_in = Button(ax_btn_zoom_in, 'Zoom +')
  216. btn_zoom_out = Button(ax_btn_zoom_out, 'Zoom -')
  217. btn_reset = Button(ax_btn_reset, 'Reset Range')
  218. btn_apply = Button(ax_btn_apply, 'Apply')
  219. btn_reset_view = Button(ax_btn_reset_view, 'Reset View')
  221. # Text for displaying current structure ID under cursor
  222. text_info = ax_img.text(0.02, 0.98, '', transform=ax_img.transAxes,
  223. fontsize=9, verticalalignment='top',
  224. bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.9))
  226. def update_image():
  227. """Update the displayed image"""
  228. current_slice_idx[0] = int(slider_slice.val)
  229. slice_data = get_slice_data()
  231. if color_mode[0] == 'by_structure':
  232. # Create RGB image using structure colors
  233. rgb_image = create_color_mapped_image(slice_data, structure_info)
  234. img.set_data(rgb_image)
  235. img.set_cmap(None) # Remove colormap for RGB
  236. img.set_clim(None, None)
  237. # Hide colorbar for structure color mode
  238. cbar.ax.set_visible(False)
  239. title_suffix = "Color by Structure"
  240. # Disable range sliders
  241. slider_vmin.ax.set_visible(False)
  242. slider_vmax.ax.set_visible(False)
  243. text_box_vmin.ax.set_visible(False)
  244. text_box_vmax.ax.set_visible(False)
  245. btn_apply.ax.set_visible(False)
  246. btn_reset.ax.set_visible(False)
  247. else:
  248. # Use ID-based coloring
  249. img.set_data(slice_data)
  250. img.set_cmap('nipy_spectral')
  251. vmin = slider_vmin.val
  252. vmax = slider_vmax.val
  253. img.set_clim(vmin, vmax)
  254. # Show colorbar for ID mode
  255. cbar.ax.set_visible(True)
  256. title_suffix = "Color by ID"
  257. # Enable range sliders
  258. slider_vmin.ax.set_visible(True)
  259. slider_vmax.ax.set_visible(True)
  260. text_box_vmin.ax.set_visible(True)
  261. text_box_vmax.ax.set_visible(True)
  262. btn_apply.ax.set_visible(True)
  263. btn_reset.ax.set_visible(True)
  265. img.set_extent([0, slice_data.shape[1], 0, slice_data.shape[0]])
  266. ax_img.set_title(f'{axis_names[current_axis[0]]} Slice {current_slice_idx[0]} (Rotation: {rotation_angle[0]}°) - {title_suffix}',
  267. fontsize=14, fontweight='bold')
  268. fig.canvas.draw_idle()
  270. def update_slice(val):
  271. """Update the displayed slice"""
  272. update_image()
  274. def on_scroll(event):
  275. """Handle mouse wheel scroll to navigate slices"""
  276. if event.inaxes == ax_img:
  277. # Get current slice and max slice
  278. current_slice = int(slider_slice.val)
  279. max_slice = annotation_data.shape[current_axis[0]] - 1
  281. # Scroll up = next slice, scroll down = previous slice
  282. if event.button == 'up':
  283. new_slice = min(current_slice + 1, max_slice)
  284. elif event.button == 'down':
  285. new_slice = max(current_slice - 1, 0)
  286. else:
  287. return
  289. # Update slider (this will trigger update_image through the slider callback)
  290. slider_slice.set_val(new_slice)
  292. def update_vmin(val):
  293. """Update minimum color value"""
  294. if color_mode[0] == 'by_id':
  295. vmin = slider_vmin.val
  296. vmax = slider_vmax.val
  297. if vmin < vmax:
  298. img.set_clim(vmin=vmin)
  299. text_box_vmin.set_val(str(int(vmin)))
  300. fig.canvas.draw_idle()
  301. else:
  302. slider_vmin.set_val(vmax - 1)
  304. def update_vmax(val):
  305. """Update maximum color value"""
  306. if color_mode[0] == 'by_id':
  307. vmin = slider_vmin.val
  308. vmax = slider_vmax.val
  309. if vmax > vmin:
  310. img.set_clim(vmax=vmax)
  311. text_box_vmax.set_val(str(int(vmax)))
  312. fig.canvas.draw_idle()
  313. else:
  314. slider_vmax.set_val(vmin + 1)
  316. def apply_manual_range(event):
  317. """Apply manually entered min/max values"""
  318. if color_mode[0] == 'by_id':
  319. try:
  320. vmin = float(text_box_vmin.text)
  321. vmax = float(text_box_vmax.text)
  323. if vmin >= vmax:
  324. print("Error: Min ID must be less than Max ID")
  325. return
  327. if vmin < data_min or vmax > data_max:
  328. print(f"Warning: Values outside data range [{data_min}, {data_max}]")
  330. slider_vmin.set_val(vmin)
  331. slider_vmax.set_val(vmax)
  332. img.set_clim(vmin=vmin, vmax=vmax)
  333. fig.canvas.draw_idle()
  334. print(f"Applied range: [{vmin}, {vmax}]")
  336. except ValueError:
  337. print("Error: Please enter valid numbers")
  339. def submit_vmin(text):
  340. """Handle text box submit for vmin"""
  341. apply_manual_range(None)
  343. def submit_vmax(text):
  344. """Handle text box submit for vmax"""
  345. apply_manual_range(None)
  347. def change_color_mode(label):
  348. """Change between ID and structure color modes"""
  349. if label == 'Color by ID':
  350. color_mode[0] = 'by_id'
  351. else:
  352. color_mode[0] = 'by_structure'
  353. update_image()
  355. def rotate_ccw(event):
  356. """Rotate counter-clockwise by 90 degrees"""
  357. rotation_angle[0] = (rotation_angle[0] - 90) % 360
  358. update_image()
  360. def rotate_cw(event):
  361. """Rotate clockwise by 90 degrees"""
  362. rotation_angle[0] = (rotation_angle[0] + 90) % 360
  363. update_image()
  365. def zoom_in(event):
  366. """Zoom in by reducing view limits"""
  367. zoom_level[0] *= 1.3
  368. xlim = ax_img.get_xlim()
  369. ylim = ax_img.get_ylim()
  371. x_center = (xlim[0] + xlim[1]) / 2
  372. y_center = (ylim[0] + ylim[1]) / 2
  373. x_range = (xlim[1] - xlim[0]) / 1.3
  374. y_range = (ylim[1] - ylim[0]) / 1.3
  376. ax_img.set_xlim(x_center - x_range/2, x_center + x_range/2)
  377. ax_img.set_ylim(y_center - y_range/2, y_center + y_range/2)
  378. fig.canvas.draw_idle()
  380. def zoom_out(event):
  381. """Zoom out by expanding view limits"""
  382. zoom_level[0] /= 1.3
  383. xlim = ax_img.get_xlim()
  384. ylim = ax_img.get_ylim()
  386. x_center = (xlim[0] + xlim[1]) / 2
  387. y_center = (ylim[0] + ylim[1]) / 2
  388. x_range = (xlim[1] - xlim[0]) * 1.3
  389. y_range = (ylim[1] - ylim[0]) * 1.3
  391. # Don't zoom out beyond initial limits
  392. slice_data = get_slice_data()
  393. max_x = slice_data.shape[1]
  394. max_y = slice_data.shape[0]
  396. new_xlim = [max(0, x_center - x_range/2), min(max_x, x_center + x_range/2)]
  397. new_ylim = [max(0, y_center - y_range/2), min(max_y, y_center + y_range/2)]
  399. ax_img.set_xlim(new_xlim)
  400. ax_img.set_ylim(new_ylim)
  401. fig.canvas.draw_idle()
  403. def reset_view(event):
  404. """Reset zoom and pan to original view"""
  405. zoom_level[0] = 1.0
  406. slice_data = get_slice_data()
  407. ax_img.set_xlim(0, slice_data.shape[1])
  408. ax_img.set_ylim(0, slice_data.shape[0])
  409. fig.canvas.draw_idle()
  411. def switch_axis(new_axis):
  412. """Switch viewing axis"""
  413. current_axis[0] = new_axis
  414. rotation_angle[0] = 0 # Reset rotation when switching axis
  416. # Update slice slider range and value
  417. current_slice_idx[0] = annotation_data.shape[new_axis] // 2
  418. slider_slice.valmax = annotation_data.shape[new_axis] - 1
  419. slider_slice.ax.set_xlim(0, annotation_data.shape[new_axis] - 1)
  420. slider_slice.set_val(current_slice_idx[0])
  422. # Reset view
  423. reset_view(None)
  425. def reset_range(event):
  426. """Reset color range to full data range"""
  427. slider_vmin.set_val(data_min)
  428. slider_vmax.set_val(data_max)
  429. text_box_vmin.set_val(str(int(data_min)))
  430. text_box_vmax.set_val(str(int(data_max)))
  432. def on_mouse_move(event):
  433. """Display structure ID and name under cursor"""
  434. if event.inaxes == ax_img and event.xdata is not None and event.ydata is not None:
  435. # Get current slice data to determine dimensions
  436. slice_data = get_slice_data()
  437. x, y = int(event.xdata), int(event.ydata)
  439. if 0 <= x < slice_data.shape[1] and 0 <= y < slice_data.shape[0]:
  440. structure_id = int(slice_data[y, x])
  442. # Get structure information
  443. if structure_id in structure_info:
  444. info = structure_info[structure_id]
  445. name = info['name']
  446. acronym = info['acronym']
  448. # Update small overlay text
  449. text_info.set_text(f'Pos: ({x}, {y})\nID: {structure_id}\n{acronym}')
  451. # Update info panel with word wrapping for long names
  452. info_display = f"Structure ID: {structure_id}\n\n"
  453. info_display += f"Acronym: {acronym}\n\n"
  454. info_display += f"Name:\n{name}\n\n"
  455. info_display += f"Position: ({x}, {y})"
  457. info_text.set_text(info_display)
  458. else:
  459. text_info.set_text(f'Pos: ({x}, {y})\nID: {structure_id}\n(Unknown)')
  460. info_text.set_text(f"Structure ID: {structure_id}\n\nName: Unknown\n\nPosition: ({x}, {y})")
  462. fig.canvas.draw_idle()
  464. # Connect callbacks
  465. slider_slice.on_changed(update_slice)
  466. slider_vmin.on_changed(update_vmin)
  467. slider_vmax.on_changed(update_vmax)
  468. text_box_vmin.on_submit(submit_vmin)
  469. text_box_vmax.on_submit(submit_vmax)
  470. radio.on_clicked(change_color_mode)
  471. btn_coronal.on_clicked(lambda event: switch_axis(0))
  472. btn_sagittal.on_clicked(lambda event: switch_axis(1))
  473. btn_axial.on_clicked(lambda event: switch_axis(2))
  474. btn_rot_ccw.on_clicked(rotate_ccw)
  475. btn_rot_cw.on_clicked(rotate_cw)
  476. btn_zoom_in.on_clicked(zoom_in)
  477. btn_zoom_out.on_clicked(zoom_out)
  478. btn_reset.on_clicked(reset_range)
  479. btn_apply.on_clicked(apply_manual_range)
  480. btn_reset_view.on_clicked(reset_view)
  481. fig.canvas.mpl_connect('motion_notify_event', on_mouse_move)
  482. fig.canvas.mpl_connect('scroll_event', on_scroll) # Add scroll event
  484. plt.show()
  486. # Main execution
  487. if __name__ == "__main__":
  488. # Define file paths
  489. annotation_filepath = r"C:\DATA\MFA\uCT\uCT2CCF\data\ccf\annotation_25.nrrd"
  490. structure_tree_filepath = r"C:\DATA\MFA\uCT\uCT2CCF\data\ccf\structure_tree.json"
  492. print("Loading annotation file...")
  493. annotation_data, header = load_annotation(annotation_filepath)
  495. print(f"Annotation shape: {annotation_data.shape}")
  496. print(f"Unique structure IDs: {len(np.unique(annotation_data))}")
  497. print(f"Data type: {annotation_data.dtype}")
  498. print(f"Min ID: {np.min(annotation_data)}, Max ID: {np.max(annotation_data)}")
  500. print("\nLoading structure tree...")
  501. structure_info = load_structure_tree(structure_tree_filepath)
  502. print(f"Loaded {len(structure_info)} brain structures")
  504. # Print first few structures to verify loading
  505. if len(structure_info) > 0:
  506. print("\nSample structures:")
  507. for i, (struct_id, info) in enumerate(list(structure_info.items())[:5]):
  508. print(f" ID {struct_id}: {info['acronym']} - {info['name']} (Color: #{info['color_hex']})")
  510. print("\nLaunching interactive viewer...")
  511. print("- Use radio buttons to switch between 'Color by ID' and 'Color by Structure'")
  512. print("- Use 'Slice' slider to navigate through slices")
  513. print("- Scroll mouse wheel over image to move through slices (up=next, down=previous)")
  514. print("- In 'Color by ID' mode: Use sliders/text boxes to adjust color range")
  515. print("- In 'Color by Structure' mode: Each region shows its anatomical color")
  516. print("- Click '↺ 90°' or '↻ 90°' to rotate the view")
  517. print("- Click 'Zoom +' or 'Zoom -' to zoom in/out")
  518. print("- Click 'Reset View' to reset zoom and rotation")
  519. print("- Hover mouse over image to see structure name and ID")
  521. interactive_viewer_advanced(annotation_data, structure_info)

annotation_loader.py at commit e73b4cc, under GPL-3.0 · at the source

Overview

Authors: Manil Bradai1, Mirna Merkler1, Gabriela Gil1, Rebecca Davie1, Shuzo Sakata1
ORCID iDs: Mirna Merkler, Shuzo Sakata
  1. Strathclyde Institute of Pharmacy and Biomedical Sciences University of Strathclyde Glasgow UK
Institutions: University of Strathclyde (United Kingdom)
Journal: The European journal of neuroscience, volume 63, issue 12, article e70582
Dates: received 23 December 2025; accepted 4 June 2026; published online 17 June 2026; in print June 2026
Type: Other · Language: English
License: CC BY
Identifiers: DOI 10.1111/ejn.70582 · PMID 42306926 · PMCID PMC13273707 · OpenAlex W7165010047
Open access: hybrid, a free copy (OpenAlex)
Status: code verified
Categories: optical imaging (calcium, voltage, 2-photon) (modality), mouse (organism), systems (subfield)
Methods: Spectral & time-frequency, Statistics, Connectivity, fMRI & imaging, Single-unit activity, calcium imaging, Physiology & signal measures, Machine learning
Keywords: brain state, cell type, fiber photometry, GCaMP, mesoscopic functional mapping
MeSH: Brain*, Brain Mapping*, GABAergic Neurons*, Photometry*, Animals, Male, Mice, Mice, Inbred C57BL, Optical Fibers (* major topic)
Journal subjects: Technical Note
Topic: Photoreceptor and optogenetics research (Cellular and Molecular Neuroscience, Neuroscience), according to OpenAlex
Funding: European Union’s Horizon 2020 (101016787); Medical Research Council (MR/Y004051/1)
Citations: not cited yet (Europe PMC); 64 references in the paper

Abstract

Mesoscopic functional brain mapping is essential for a better understanding of various brain functions and dysfunctions. However, accessing distributed neural circuits in mammalian brain regions remains a significant challenge. While fiber photometry is a versatile optical approach, existing methods often suffer from invasiveness and limited scalability. Here we present an affordable multifiber array (MFA)‐based photometry system to monitor neural signals across multiple regions. Our system comprises a custom‐designed MFA utilizing 50‐μm diameter optical fibers and off‐the‐shelf optical components. To demonstrate the system's versatility, we monitored GABAergic population activity using jGCaMP8s across multiple brain regions in head‐fixed, awake mice. By combining this approach with pupillometry, we identified state‐dependent, region‐specific GABAergic dynamics. Our MFA‐based photometry system opens new avenues for investigating state‐dependent neural dynamics at the mesoscopic level. To facilitate wider adoption, all code and resources are publicly available on GitHub (https://github.com/Sakata‐Lab/MFA).

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

Repositories

Its files are read in the Code ↔ Paper reader above.

Sakata-Lab/mfaCTpy

License: GPL-3.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: e73b4cc0b7151b381d0d81fa2411a12c4b336743, 25 June 2026
Languages: Python (10)
Size: 12 files, 10 scripts
Software Heritage: not archived
Found in: the text, “μCT Image Analysis”
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (10 files), Matplotlib (9 files), tifffile (9 files), SimpleITK (4 files), SciPy (3 files), OpenCV (1 file), pandas (1 file), Pillow (1 file), pydicom (1 file), scikit-image (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
12 files
At the source: github.com/Sakata-Lab/mfaCTpy

Sakata-Lab/MFA

License: GPL-3.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 48f7ec65ead581f733ee3c718848428eed6bc7f2, 25 June 2026
Languages: MATLAB (1)
Size: 11 files, 1 script
Software Heritage: not archived
Found in: “Data Availability Statement”
Holds: README, license file, 1 notebook
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
3 files
At the source: github.com/Sakata-Lab/MFA

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:

  • 2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 11 scripts, each with its path and the digest of its content;
  • no match between paragraphs and code yet;
  • 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

Code and resources are available on GitHub (https://github.com/Sakata‐Lab/MFA (https://github.com/Sakata-Lab/MFA)). Data is available online at https://doi.org/10.15129/9f8ce34b‐f058‐4c4e‐b10b‐efd96fe1b047 (https://doi.org/10.15129/9f8ce34b-f058-4c4e-b10b-efd96fe1b047). All other data underlying this article will be shared on reasonable request to the corresponding author.

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 2, 28 September 2026

  • Publisher: — → Wiley

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 5 authors, 5 keywords, 9 MeSH terms, 2 funders, 64 references.

Cite

This paper

Bradai, M., Merkler, M., Gil, G., Davie, R., & Sakata, S. (2026). Multifiber Array-Based Photometry System for Multiregional Functional Mapping in the Mouse Brain. The European journal of neuroscience, 63(12), e70582. https://doi.org/10.1111/ejn.70582

BibTeX

@article{bradai2026multifiber,
author = {Bradai, Manil and Merkler, Mirna and Gil, Gabriela and Davie, Rebecca and Sakata, Shuzo},
title = {{Multifiber Array-Based Photometry System for Multiregional Functional Mapping in the Mouse Brain}},
journal = {The European journal of neuroscience},
year = {2026},
month = jun,
volume = {63},
number = {12},
pages = {e70582},
publisher = {Wiley},
issn = {0953-816X},
doi = {10.1111/ejn.70582},
url = {https://doi.org/10.1111/ejn.70582},
pmid = {42306926},
pmcid = {PMC13273707}
}

RIS

TY - JOUR
AU - Bradai, Manil
AU - Merkler, Mirna
AU - Gil, Gabriela
AU - Davie, Rebecca
AU - Sakata, Shuzo
TI - Multifiber Array-Based Photometry System for Multiregional Functional Mapping in the Mouse Brain
T2 - The European journal of neuroscience
J2 - Eur J Neurosci
PY - 2026
DA - 2026/06/01
VL - 63
IS - 12
SP - e70582
SN - 0953-816X
PB - Wiley
DO - 10.1111/ejn.70582
UR - https://doi.org/10.1111/ejn.70582
LA - en
ER -

CSL-JSON

{
"id": "10.1111/ejn.70582",
"type": "article-journal",
"title": "Multifiber Array-Based Photometry System for Multiregional Functional Mapping in the Mouse Brain",
"container-title": "The European journal of neuroscience",
"author": [
{
"family": "Bradai",
"given": "Manil"
},
{
"family": "Merkler",
"given": "Mirna"
},
{
"family": "Gil",
"given": "Gabriela"
},
{
"family": "Davie",
"given": "Rebecca"
},
{
"family": "Sakata",
"given": "Shuzo"
}
],
"container-title-short": "Eur J Neurosci",
"volume": "63",
"issue": "12",
"page": "e70582",
"DOI": "10.1111/ejn.70582",
"PMID": "42306926",
"PMCID": "PMC13273707",
"ISSN": "0953-816X",
"publisher": "Wiley",
"URL": "https://doi.org/10.1111/ejn.70582",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
1
]
]
}
}

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.1016/j.isci.2026.116206 [code]
Gut distension evokes rapid neural dynamics in vagal and hindbrain populations of larval zebrafish.
Journal: iScience
In common: SimpleITK, tifffile, OpenCV, 6 other tools, optical imaging (calcium, voltage, 2-photon), systems, 2 references
[2] doi:10.7554/elife.109717 [code]
Retrosplenial cortex enables context-dependent goal-directed sensorimotor transformation.
Journal: eLife
In common: tifffile, OpenCV, scikit-image, 5 other tools, systems, mouse, 3 references
[3] doi:10.1038/s41467-026-72710-3 [code]
A modular multi-color fluorescence microscope for simultaneous tracking of cellular activity and behavior.
Journal: Nature communications
In common: tifffile, OpenCV, scikit-image, 5 other tools, optical imaging (calcium, voltage, 2-photon), 3 references
[4] doi:10.1038/s41593-026-02232-0 [code]
Entorhinal cortex represents task-relevant remote locations independently of CA1.
Journal: Nature neuroscience
In common: OpenCV, scikit-image, Pillow, 4 other tools, systems, mouse, 4 references
[5] doi:10.1364/boe.605322 [code]
Generalized plaque digitization framework for multi-dimensional mesoscopic images.
Journal: Biomedical optics express
In common: SimpleITK, tifffile, OpenCV, 6 other tools, mouse, 1 reference
[6] doi: [code]
Real-time closed-loop feedback system for mouse mesoscale cortical signal and movement control
Journal: eLife
In common: tifffile, OpenCV, scikit-image, 5 other tools, optical imaging (calcium, voltage, 2-photon), mouse, 2 references
[7] doi:10.21203/rs.3.rs-10218667/v1 [code]
Combining ultra-flexible electrodes with two-photon imaging to illuminate brain-wide neural dynamics
Journal: Research Square (preprint)
In common: SciPy, Matplotlib, NumPy, optical imaging (calcium, voltage, 2-photon), systems, 6 references
[8] doi:10.3389/fnins.2026.1893619 [code]
Direct laser carbonization of parylene-C toward microelectrodes for &lt;i&gt;in vivo&lt;/i&gt; action potential detection.
Journal: Frontiers in neuroscience
In common: scikit-image, Pillow, pandas, 3 other tools, 5 references
[9] doi:10.1016/j.crmeth.2026.101481 [code]
A hybrid micro-ECoG for functionally targeted multi-site and multi-scale investigation.
Journal: Cell reports methods
In common: systems, 8 references
[10] doi:10.7554/elife.110277 [code]
Functional imaging of nine distinct neuronal populations under a miniscope in freely behaving animals.
Journal: eLife
In common: SimpleITK, tifffile, OpenCV, 4 other tools, optical imaging (calcium, voltage, 2-photon), systems, mouse, 1 reference

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.