OSCR

Motor cortex directly excites the substantia nigra pars reticulata, the basal ganglia output nucleus.

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 · 1,518 lines · 50 KB · GPL-3.0

  1. #!/usr/bin/env python3
  2. # -*- coding: utf-8 -*-
  3. """
  4. Created on Wed Jan 14 17:20:00 2026
  6. @author: wst
  9. visualisation tools for Snudda & Blender
  10. requires Blender 4.0 > with a functional python installation
  12. """
  14. import sys
  15. import os
  16. import bpy
  17. import bmesh
  18. import h5py
  20. import mathutils
  21. import math
  22. import random
  23. import numpy as np
  25. from snudda.utils.snudda_path import snudda_parse_path
  26. from snudda import SnuddaLoad
  29. # default_colours = [(0.168, 0.416, 0.8), (0.8, 0.294, 0.134)]
  30. # snr_colour = [52 / 255, 168 / 255, 224 / 255, 1]
  31. # midline = 5691.66
  33. ### Allen import convention: axis_forward = 'Y', axis_up = 'Z'
  34. ### coord_conv = {'Mouselight': {'X':4, 'Y':3, 'Z':2}, 'Peng': {'X':2, 'Y':3, 'Z':4}}
  37. def clear_scene(bg_colour=(1, 1, 1, 1), clipping=1e6, raw_colours=True):
  38. """
  39. clears all objects from active blender scene, and (optionallly) sets background colour.
  41. bg_colour (RGBA, optional): colour to set blender background to. Default: (1,1,1,1).
  42. clipping (float, opional): distance at which objects will be clipped in the default viewer. For Allen meshes a value of 1e6 is reasonable to keep all objects in view. Default: 1e6.
  43. raw_colours (bool, optional): If True, sets blender view transform to 'Raw', such that colours are not modified by blender (ie., RGB values will be preserved in render). Default: True.
  44. """
  46. if bpy.context.mode != "OBJECT":
  47. bpy.ops.object.mode_set(mode="OBJECT")
  49. bpy.ops.object.select_all(action="SELECT")
  50. bpy.ops.object.delete(use_global=False)
  52. if bg_colour:
  53. assert len(bg_colour) == 4, "colour must RGBA"
  54. bpy.data.worlds["World"].node_tree.nodes["Background"].inputs[
  55. 0
  56. ].default_value = bg_colour
  58. for area in bpy.context.screen.areas:
  59. if area.type == "VIEW_3D":
  60. for space in area.spaces:
  61. if space.type == "VIEW_3D":
  62. space.clip_end = clipping
  63. space.shading.type = 'RENDERED'
  65. if raw_colours:
  66. bpy.context.scene.view_settings.view_transform = "Raw"
  69. return
  72. def frame_selected():
  73. """
  74. frames selected objects in blender viewer.
  76. """
  78. for area in bpy.context.screen.areas:
  79. if area.type == "VIEW_3D":
  80. for region in area.regions:
  81. if region.type == "WINDOW":
  82. override = {
  83. "area": area,
  84. "region": region,
  85. "edit_object": bpy.context.edit_object,
  86. }
  87. with bpy.context.temp_override(**override):
  88. bpy.ops.view3d.view_selected(use_all_regions=False)
  89. break
  90. break
  92. return
  95. def frame_all():
  96. """
  97. frames all objects in blender viewer.
  99. """
  101. for area in bpy.context.screen.areas:
  102. if area.type == "VIEW_3D":
  103. for region in area.regions:
  104. if region.type == "WINDOW":
  105. override = {
  106. "area": area,
  107. "region": region,
  108. "edit_object": bpy.context.edit_object,
  109. }
  110. with bpy.context.temp_override(**override):
  111. bpy.ops.view3d.view_axis(type="TOP")
  112. bpy.ops.view3d.view_all()
  113. break
  114. break
  116. return
  119. def set_coronal_view():
  120. """
  121. sets 3D view to coronal (following Allen mesh conventions)
  123. """
  124. for area in bpy.context.screen.areas:
  125. if area.type == "VIEW_3D":
  126. space = area.spaces.active
  127. region_3d = space.region_3d
  128. base_quat = mathutils.Quaternion((0.5, 0.5, 0.5, 0.5))
  129. roll_quat = mathutils.Quaternion((1.0, 0.0, 0.0), math.radians(90))
  130. region_3d.view_rotation = roll_quat @ base_quat
  131. region_3d.view_perspective = "ORTHO"
  132. break
  133. return
  136. def bulletproof_name(name):
  137. """
  139. returns a new name if the name is already in use. This avoids conflicts with blender object operations.
  141. name (str): desired name.
  143. returns:
  144. name (str): desired name with a numeric suffix.
  146. """
  148. base = name
  149. i = 1
  151. while name in bpy.data.objects:
  152. name = f"{base}.{i:03d}"
  153. i += 1
  154. return name
  157. def collect_meshes(name):
  158. """
  160. returns a Blender collection by name, or creates a new one if necessary.
  161. name (str): name of collection.
  163. returns:
  164. col (bpy.types.Collection)
  166. """
  167. if name in bpy.data.collections:
  168. return bpy.data.collections[name]
  169. col = bpy.data.collections.new(name)
  170. bpy.context.scene.collection.children.link(col)
  171. return col
  174. def is_inside(p, obj):
  175. """
  176. checks if a point is inside a blender object.
  178. p (list of floats): 3D coordinate
  179. obj (bpy.types.Object): Blender mesh object
  181. returns:
  183. True if p is inside obj.
  185. """
  186. p = mathutils.Vector(p)
  188. result, closest, normal, _ = obj.closest_point_on_mesh(p)
  189. direction = p - closest
  191. return direction.dot(normal) < 0
  194. def distance_to_mesh(p, obj):
  195. """
  196. calculates distance from a given point to the surface of a blender object.
  198. p (list of floats): 3D coordinate.
  199. obj (bpy.types.Object): blender mesh object.
  201. returns:
  203. distance (float): distance to mesh surface.
  204. nearest_point (mathutils.Vector): point on mesh surface nearest to specified point.
  206. """
  208. p = mathutils.Vector(p)
  210. bm = bmesh.new()
  211. bm.from_mesh(obj.data)
  212. bm.transform(obj.matrix_world)
  214. bvh = mathutils.bvhtree.BVHTree.FromBMesh(bm)
  215. nearest_point, normal, index, distance = bvh.find_nearest(p)
  217. bm.free()
  219. return distance, nearest_point
  222. ##### not necessary but can provide significant speed ups for large arrays of coordinates
  223. # from numba import jit
  224. # @jit(nopython=True)
  225. # def distance_numba(point1, point2):
  226. # dx = point2[0] - point1[0]
  227. # dy = point2[1] - point1[1]
  228. # dz = point2[2] - point1[2]
  229. # return math.sqrt(dx*dx + dy*dy + dz*dz)
  232. def get_mesh_volume(obj, scale_f=1e-9):
  233. """
  234. calculates volume of blender object.
  236. obj (bpy.types.Object): blender mesh object
  237. scale_f (float): scaling factor for conversion to desired unit. Default: 1e-9 (converts Allen mesh volumes to mm^3).
  239. returns:
  240. volume (float): volume, mutlitplied by optional scaling factor.
  241. """
  243. me = obj.data
  245. bm = bmesh.new()
  246. bm.from_mesh(me)
  247. bm.transform(obj.matrix_world)
  248. bmesh.ops.triangulate(bm, faces=bm.faces)
  250. volume = 0
  251. for f in bm.faces:
  252. v1, v2, v3 = [v.co for v in f.verts[:3]]
  253. volume += v1.dot(v2.cross(v3)) / 6
  254. bm.free()
  256. return volume * scale_f
  259. def random_RGBA(low=50, high=255, alpha=1):
  260. """
  261. generates a random RGBA. Use low/high limits to control colour darkness for contrast with scene (i.e., 0-100 for dark objects on white backgrounds).
  263. """
  265. return tuple(np.random.randint(low, high, size=3) / 255) + (alpha,)
  268. def flip_mesh_across_midline(obj, midline=5691.66):
  269. """
  270. flip blender object across midline
  271. obj (bpy.types.Object): blender mesh object.
  272. midline: midline of brain. Default: 5691.66.
  274. """
  275. obj.scale.z *= -1
  276. if obj.parent:
  277. obj.parent.location = [
  278. obj.parent.location[0],
  279. obj.parent.location[1],
  280. 2 * midline - obj.parent.location[2],
  281. ]
  283. else:
  284. obj.location = [obj.location[0], obj.location[1], 2 * midline - obj.location[2]]
  286. return
  289. def bisect_object(obj, plane="sagittal", location=5691.66, inner = False, outer = True):
  290. """
  291. splits mesh objects at specified plane
  292. obj (bpy.types.Object): blender mesh object.
  293. plane (str): desired plane, accepts 'sagittal', 'coronal' or 'horizontal'. Follows conventions of Allen meshes.
  294. location (float): location along axis to bisect.
  295. inner (bool): keep inner side of obj.
  296. outer (bool): keep outer side of obj.
  298. """
  300. assert plane.lower() in [
  301. "sagittal",
  302. "coronal",
  303. "horizontal",
  304. ], f"Ensure plane is one of sagittal, coronal, or horizontal. Received: {plane}."
  306. bpy.ops.object.select_all(action="DESELECT")
  307. bpy.context.view_layer.objects.active = obj
  308. obj.select_set(True)
  309. bpy.ops.object.mode_set(mode='EDIT')
  311. bpy.ops.mesh.select_all(action="SELECT")
  313. plane_key = {"sagittal": 2, "coronal": 0, "horizontal": 1}
  315. plane_co = [0, 0, 0]
  316. plane_no = [0, 0, 0]
  318. plane_co[plane_key[plane.lower()]] = location
  319. plane_no[plane_key[plane.lower()]] = 1
  321. bpy.ops.mesh.bisect(
  322. plane_co=plane_co,
  323. plane_no=plane_no,
  324. use_fill=True,
  325. clear_inner=inner,
  326. clear_outer=outer,
  327. threshold=0.0001,
  328. )
  330. bpy.ops.object.mode_set(mode="OBJECT")
  332. return
  335. def set_origin_to_center(obj):
  336. """
  337. sets origin to center of volume of object
  338. obj (bpy.types.Object): blender mesh object.
  340. returns:
  341. obj.location: (XYZ)
  342. """
  344. if bpy.context.active_object and bpy.context.active_object.mode != "OBJECT":
  345. bpy.ops.object.mode_set(mode="OBJECT")
  346. bpy.ops.object.select_all(action="DESELECT")
  347. obj.select_set(True)
  348. bpy.context.view_layer.objects.active = obj
  349. bpy.ops.object.origin_set(type="ORIGIN_CENTER_OF_VOLUME")
  351. return obj.location
  354. def add_tracked_camera(
  355. target_name,
  356. rotate=True,
  357. rotation_time = 360,
  358. coronal=True,
  359. x_res=2160,
  360. y_res=2160,
  361. altitude=0,
  362. cam_clip_end=1e6,
  363. cam_type="ORTHO",
  364. cam_scale=2e4,
  365. ):
  366. """
  367. adds a camera to the scene, tracked to the center of a specified object.
  369. target_name (str): name of object to track to.
  370. rotate (bool): whether the camera should rotate about the object.
  371. rotation_time (int, optional): time (in keyframes) for a full rotation. Default: 360.
  372. coronal (bool): if True, will set a coronal view (Allen convention).
  373. x_res, y_res (int): resolution of x and y axes of camera (px).
  374. altitude (float): altitude of camera angle w.r.t. horizontal plane, in degrees. Default: 0.
  375. cam_clip_end (float): clipping threshold of camera. Default: 1e6.
  376. cam_type (str): camera type. Default: 'ORTHO'.
  377. cam_scale (float): camera scaling (i.e., zoom) for orthogonal cameras. Default: 2e4.
  378. """
  380. assert cam_type in ['PERSP', 'ORTHO', 'PANO', 'CUSTOM'], 'Check camera type!'
  382. x_res = round(x_res)
  383. y_res = round(y_res)
  385. target = bpy.data.objects[target_name]
  386. set_origin_to_center(target)
  387. frame_selected()
  389. if coronal:
  390. set_coronal_view()
  392. bpy.ops.object.empty_add(type="PLAIN_AXES", location=target.location)
  393. bpy.ops.object.camera_add()
  395. cam = bpy.data.objects["Camera"]
  396. bpy.context.scene.camera = cam
  398. for area in bpy.context.window.screen.areas:
  399. if area.type == "VIEW_3D":
  400. for region in area.regions:
  401. if region.type == "WINDOW":
  402. with bpy.context.temp_override(
  403. window=bpy.context.window,
  404. screen=bpy.context.window.screen,
  405. area=area,
  406. region=region,
  407. space_data=area.spaces.active,
  408. scene=bpy.context.scene,
  409. ):
  410. bpy.ops.view3d.camera_to_view()
  411. break
  412. break
  414. cam.data.clip_end = cam_clip_end
  415. cam.data.type = cam_type
  416. if cam_type == "ORTHO":
  417. cam.data.ortho_scale = cam_scale
  419. em = bpy.data.objects["Empty"]
  421. bpy.ops.object.mode_set(mode="OBJECT")
  422. bpy.ops.object.select_all(action="DESELECT")
  423. cam.select_set(True)
  424. em.select_set(True)
  425. bpy.context.view_layer.objects.active = em
  426. bpy.ops.object.parent_set(type="OBJECT", keep_transform=True)
  428. if rotate:
  429. em.rotation_euler = [0, 0, math.radians(altitude)]
  430. em.keyframe_insert(data_path="rotation_euler", frame=1)
  431. em.rotation_euler = [0, math.radians(360), math.radians(altitude)]
  432. em.keyframe_insert(data_path="rotation_euler", frame=rotation_time)
  434. bpy.data.scenes["Scene"].frame_end = rotation_time
  436. for fcurve in em.animation_data.action.fcurves:
  437. for keyframe in fcurve.keyframe_points:
  438. keyframe.interpolation = "LINEAR"
  439. bpy.data.scenes["Scene"].render.resolution_x = x_res
  440. bpy.data.scenes["Scene"].render.resolution_y = y_res
  441. return
  444. def animate_visibility(obj, frame, on=True):
  445. """
  446. animates the visibility of an object in both render and viewport.
  448. obj (bpy.types.Object): blender mesh object.
  449. frame (int): keyframe at which the object should change visibility
  450. on (bool): if True, the object will start invisibile and become visibile at frame. If False, the inverse will occur. Default: True.
  452. """
  454. bpy.context.scene.frame_set(1)
  455. obj.hide_render = on
  456. obj.keyframe_insert(data_path="hide_render", frame=1)
  457. obj.hide_viewport = on
  458. obj.keyframe_insert(data_path="hide_viewport", frame=1)
  460. bpy.context.scene.frame_set(frame)
  461. obj.hide_render = ~on
  462. obj.keyframe_insert(data_path="hide_render", frame=frame)
  463. obj.hide_viewport = ~on
  464. obj.keyframe_insert(data_path="hide_viewport", frame=frame)
  466. for fcurve in obj.animation_data.action.fcurves:
  467. for keyframe in fcurve.keyframe_points:
  468. keyframe.interpolation = "LINEAR"
  469. return
  472. def build_from_swc(
  473. filepath,
  474. name=None,
  475. lx=0,
  476. ly=0,
  477. lz=0,
  478. coord_space=None,
  479. flip=False,
  480. midline=5691.66,
  481. rotate=False,
  482. rotating=None,
  483. rotation_time = 360,
  484. draw_axon=False,
  485. fill_process_tips=False,
  486. merge_threshold=0.001,
  487. scale_f=1,
  488. colour=None,
  489. alpha=1,
  490. ):
  491. """
  492. renders a neuron in blender from an .swc file, using bezier curves.
  494. Inspired by https://github.com/Hjorthmedh/Snudda/blob/master/snudda/plotting/Blender/io_mesh_swc/operator_swc_import.py
  496. filepath (str): path to SWC file of neuron to be rendered
  497. name (str, optional): neuron name, will be passed to object name in Blender. Default: None.
  498. lx, ly, lz (float, optional): soma offsets in XYZ. Default: 0.
  499. coord_space (dict, optional): specified coordinate space if different from default. Default: {'X':2, 'Y':3, 'Z':4}.
  500. flip (bool, optional): if True, flips the neuron about the midline.
  501. midline (float, optional): midline of brain (Allen CCF). Default 5691.66.
  502. rotate (bool, optional): Applies random rotatation if true. Will be overriden by 'rotating'.
  503. rotating (str, optional): Animates rotation about specified axis. Will override 'rotate'. Default: None.
  504. rotation_time (int, optional): time (in keyframes) for a full rotation. Default: 360.
  505. draw_axon (bool, optional): If False, axons (ie., SWC type 2) will not be rendered.
  506. fill_process_tips (bool optional): If True, fills neurite tips with spheres for aesthetics. Warning: slow for large numbers of neurons.
  507. merge_threshold (float, optional): Distance within which vertices will be merged. Higher values reduce the complexity of the resulting object. Default: 0.001.
  508. scale_f (float, optional): Scaling factor for neuron size. Default: 1 (ie., 1:1).
  509. colour (RGBA, optional): Colour to render neuron in. If not specfied a random colour will be generated.
  510. alpha (float, optional): Alpha value (transparency) for neuron material. Must be in the interval [0,1]. Default: 1.
  512. """
  514. f = open(filepath)
  515. lines = f.readlines()
  516. f.close()
  518. x = 0
  519. while lines[x][0] == "#":
  520. x += 1
  521. if coord_space:
  522. coord_space = coord_space
  523. else:
  524. coord_space = {"X": 2, "Y": 3, "Z": 4}
  526. data = lines[x].strip().split()
  527. somaID = int(data[0])
  528. somaType = float(data[1])
  529. somaX = float(data[coord_space["X"]]) + lx
  530. somaY = float(data[coord_space["Y"]]) + ly
  531. somaZ = float(data[coord_space["Z"]]) + lz
  532. somaR = float(data[5])
  533. somaParent = int(data[6])
  535. neuron = {somaID: [somaType, somaX, somaY, somaZ, somaR, somaParent]}
  537. x += 1
  539. for l in lines[x:]:
  540. data = l.strip().split()
  541. compID = int(data[0])
  542. compType = float(data[1])
  543. compX = float(data[coord_space["X"]]) + lx
  544. compY = float(data[coord_space["Y"]]) + ly
  545. compZ = float(data[coord_space["Z"]]) + lz
  546. compR = float(data[5])
  547. compParent = int(data[6])
  548. neuron[compID] = [
  549. compType,
  550. compX - somaX,
  551. compY - somaY,
  552. compZ - somaZ,
  553. compR,
  554. compParent,
  555. ]
  557. if bpy.context.mode != "OBJECT":
  558. bpy.ops.object.mode_set(mode="OBJECT")
  560. bpy.ops.object.empty_add(
  561. type="ARROWS",
  562. location=(
  563. neuron[1][1] / scale_f,
  564. neuron[1][2] / scale_f,
  565. neuron[1][3] / scale_f,
  566. ),
  567. rotation=(0, 0, 0),
  568. )
  569. em = bpy.context.selected_objects[0]
  571. if not name:
  572. name = "neuron"
  574. em.name = bulletproof_name(name)
  576. if rotating:
  577. assert rotating.lower() in ['x', 'y', 'z'], f'{rotating} not an axis name'
  579. em.rotation_euler = [0, 0, 0]
  580. em.keyframe_insert(data_path="rotation_euler", frame=1)
  582. r_dict = {'x': 0, 'y':1, 'z': 2}
  583. em.rotation_euler[r_dict[rotating.lower()]] = math.radians(360)
  585. em.keyframe_insert(data_path="rotation_euler", frame=rotation_time)
  587. bpy.data.scenes["Scene"].frame_end = rotation_time
  589. for fcurve in em.animation_data.action.fcurves:
  590. for keyframe in fcurve.keyframe_points:
  591. keyframe.interpolation = "LINEAR"
  593. elif rotate:
  595. em.rotation_euler = [0, random.randrange(0, 30), random.randrange(0, 360)]
  597. if not colour:
  598. colour = random_RGBA()
  599. else:
  600. assert len(colour) == 4, "colour must RGBA"
  602. material = bpy.data.materials.new(name=str(name) + "_mat")
  603. material.use_nodes = True
  604. pbsdf_node = material.node_tree.nodes["Principled BSDF"]
  605. pbsdf_node.inputs["Base Color"].default_value = colour
  606. pbsdf_node.inputs["Metallic"].default_value = 0
  607. pbsdf_node.inputs["Roughness"].default_value = 1
  608. pbsdf_node.inputs["Specular IOR Level"].default_value = 0.05
  609. pbsdf_node.inputs["Sheen Weight"].default_value = 0
  610. pbsdf_node.inputs["Alpha"].default_value = alpha
  611. material.blend_method = "BLEND"
  613. last = 0
  615. for key, value in neuron.items():
  616. if value[0] == 1: # soma
  617. somaRadie = somaR
  618. bpy.ops.mesh.primitive_uv_sphere_add(
  619. location=(0 / scale_f, 0 / scale_f, 0 / scale_f),
  620. radius=somaRadie / scale_f,
  621. segments=64,
  622. ring_count=64,
  623. )
  624. somaObj = bpy.context.selected_objects[0]
  625. somaObj.name = "Soma"
  626. somaObj.parent = em
  627. somaObj.data.materials.append(material)
  628. last = -10
  630. if value[-1] == -1:
  631. continue
  632. if value[0] == 10:
  633. continue
  634. if value[0] == 5:
  635. continue
  636. if draw_axon == False:
  637. if value[0] == 2:
  638. continue
  640. if value[-1] != last:
  641. if fill_process_tips:
  642. if last != -10:
  643. bpy.ops.mesh.primitive_uv_sphere_add(
  644. radius=p.radius,
  645. location=p.co,
  646. scale=(1, 1, 1),
  647. segments=32,
  648. ring_count=16,
  649. )
  650. obj = bpy.context.selected_objects[0]
  651. obj.data.polygons.foreach_set(
  652. "use_smooth", [True] * len(obj.data.polygons)
  653. )
  654. obj.active_material = material
  655. obj.parent = em
  657. # trace the origins
  658. tracer = bpy.data.curves.new("tracer", "CURVE")
  659. tracer.dimensions = "3D"
  660. spline = tracer.splines.new("BEZIER")
  661. curve = bpy.data.objects.new("curve", tracer)
  662. curve.data.use_fill_caps = False
  663. curve.data.materials.append(material)
  665. bpy.context.scene.collection.objects.link(curve)
  667. # render ready curve
  668. tracer.resolution_u = 12
  669. tracer.bevel_resolution = 12
  670. tracer.fill_mode = "FULL"
  671. tracer.bevel_depth = 1.0
  673. # move nodes to objects
  674. p = spline.bezier_points[0]
  675. if neuron[value[-1]][1] == somaX:
  676. xco = 0
  677. else:
  678. xco = neuron[value[-1]][1]
  679. if neuron[value[-1]][2] == somaY:
  680. yco = 0
  681. else:
  682. yco = neuron[value[-1]][2]
  683. if neuron[value[-1]][3] == somaZ:
  684. zco = 0
  685. else:
  686. zco = neuron[value[-1]][3]
  688. p.co = [xco, yco, zco]
  689. p.radius = neuron[value[-1]][4]
  690. p.handle_right_type = "VECTOR"
  691. p.handle_left_type = "VECTOR"
  693. if last > 0:
  694. spline.bezier_points.add(1)
  695. p = spline.bezier_points[-1]
  696. p.co = [value[1] / scale_f, value[2] / scale_f, value[3] / scale_f]
  697. p.radius = value[4] / scale_f
  698. p.handle_right_type = "VECTOR"
  699. p.handle_left_type = "VECTOR"
  701. curve.parent = em
  703. # continue the last bezier curve
  704. if value[-1] == last:
  705. spline.bezier_points.add(1)
  706. p = spline.bezier_points[-1]
  707. p.co = [value[1] / scale_f, value[2] / scale_f, value[3] / scale_f]
  708. p.radius = value[4] / scale_f
  709. p.handle_right_type = "VECTOR"
  710. p.handle_left_type = "VECTOR"
  712. last = key
  714. ##fill in end of processes, can be slow
  715. if fill_process_tips:
  716. bpy.ops.mesh.primitive_uv_sphere_add(
  717. radius=p.radius, location=p.co, scale=(1, 1, 1), segments=32, ring_count=16
  718. )
  719. obj = bpy.context.selected_objects[0]
  720. obj.data.polygons.foreach_set("use_smooth", [True] * len(obj.data.polygons))
  721. obj.active_material = material
  722. obj.parent = em
  724. ##merge all objects into single object
  725. for obj in bpy.data.objects[name].children:
  726. if "curve" in obj.name:
  727. obj.select_set(True)
  728. bpy.context.view_layer.objects.active = obj
  729. bpy.ops.object.convert(target="MESH", keep_original=False)
  730. elif "Sphere" in obj.name:
  731. obj.select_set(True)
  732. bpy.context.view_layer.objects.active = obj
  733. elif "Soma" in obj.name:
  734. obj.select_set(True)
  735. bpy.context.view_layer.objects.active = obj
  737. soma = next(
  738. (obj for obj in bpy.data.objects[name].children if "Soma" in obj.name), None
  739. )
  741. bpy.ops.object.select_all(action="DESELECT")
  743. for obj in bpy.data.objects[name].children:
  744. obj.select_set(True)
  746. bpy.context.view_layer.objects.active = soma
  748. if bpy.context.active_object.mode != "OBJECT":
  749. bpy.ops.object.mode_set(mode="OBJECT")
  751. bpy.ops.object.join()
  753. bpy.ops.object.mode_set(mode="EDIT")
  754. bpy.ops.mesh.select_all(action="SELECT")
  756. bpy.ops.mesh.remove_doubles(
  757. threshold=merge_threshold,
  758. use_unselected=False,
  759. use_sharp_edge_from_normals=False,
  760. )
  761. bpy.ops.object.mode_set(mode="OBJECT")
  762. joined_obj = bpy.context.active_object
  763. joined_obj.name = name
  764. joined_obj.data.use_auto_smooth = True
  765. joined_obj.data.auto_smooth_angle = math.pi / 2
  767. if flip:
  768. flip_mesh_across_midline(joined_obj, midline)
  770. return joined_obj
  773. def import_allen_mesh(
  774. filepath, forward_axis="Y", up_axis="Z", colour=None, alpha=1, bf_cull=False
  775. ):
  776. """
  777. imports .obj files from Allen SDK to blender.
  779. filepath (str): path to .obj file
  780. forward_axis, up_axis (str, optional): 'X', 'Y', 'Z', axes for blender orientation
  781. colour (RGBA, optional): colour to render mesh in. If not specfied a random colour will be generated.
  782. alpha (float, optional): alpha value (transparency) for neuron material. Must be in the interval [0,1]. Default: 1.
  784. returns:
  785. obj (bpy.types.Object): blender mesh object of Allen region.
  786. """
  788. assert filepath.endswith(".obj"), "Expected .obj file."
  790. if not colour:
  791. colour = random_RGBA()
  792. else:
  793. assert len(colour) == 4, "colour must RGBA"
  795. bpy.ops.wm.obj_import(filepath=filepath, forward_axis=forward_axis, up_axis=up_axis)
  796. material = bpy.data.materials.new(name="mat")
  797. material.use_nodes = True
  798. pbsdf_node = material.node_tree.nodes["Principled BSDF"]
  799. pbsdf_node.inputs["Base Color"].default_value = colour
  800. pbsdf_node.inputs["Metallic"].default_value = 0
  801. pbsdf_node.inputs["Roughness"].default_value = 0
  802. pbsdf_node.inputs["Specular IOR Level"].default_value = 0
  803. pbsdf_node.inputs["Alpha"].default_value = alpha
  804. material.blend_method = "BLEND"
  805. material.use_backface_culling = bf_cull
  806. mesh = bpy.context.selected_objects[0]
  807. mesh.active_material = material
  809. return mesh
  812. def spherical_sample(n, ndim=3):
  813. """
  814. returns n randdom points on the surface of a unit sphere.
  816. n (int): number of points
  817. """
  819. vec = np.random.randn(ndim, n)
  820. vec /= np.linalg.norm(vec, axis=0)
  821. return vec.T
  824. def mesh_from_coordinates(coordinates, name=None, reference_object=None, scale_f=1):
  825. """
  826. creates a blender object from a set of coordinates, placing a reference object at each coordinate.
  827. Helpful for mapping out soma or synapse positions.
  829. coordinates (Nx3 array): coordinates of interest.
  830. reference_object (blender object, optional): specific blender object to place at each coordinate. Object should be centered at [0,0,0]. If None, a sphere will be generated.
  831. scale_f (float, optional): scaling factor for coordinates to blender space. Default: 1e6.
  833. returns:
  834. obj (bpy.types.Object): blender mesh object.
  835. """
  837. if not name:
  838. name = "coordinates"
  840. mesh = bpy.data.meshes.new("coordinates")
  841. mesh_object = bpy.data.objects.new("coordinates", mesh)
  842. mesh_object.name = f"{name}_temp"
  844. mesh.from_pydata(coordinates * scale_f, [], [])
  845. mesh.update(calc_edges=True)
  847. bpy.context.scene.cursor.location = [0, 0, 0]
  848. mesh_object.location = bpy.context.scene.cursor.location
  849. bpy.data.collections["Collection"].objects.link(mesh_object)
  851. if not reference_object:
  852. material = bpy.data.materials.new(name="mat")
  853. material.use_nodes = True
  854. pbsdf_node = material.node_tree.nodes["Principled BSDF"]
  855. pbsdf_node.inputs["Base Color"].default_value = (0, 0, 0, 1)
  857. bpy.ops.mesh.primitive_uv_sphere_add(
  858. location=[0, 0, 0], radius=10, segments=16, ring_count=16
  859. )
  860. reference_object = bpy.context.selected_objects[0]
  861. reference_object.data.materials.append(material)
  863. reference_object.parent = mesh_object
  864. mesh_object.instance_type = "VERTS"
  865. bpy.ops.object.select_all(action="DESELECT")
  867. mesh_object.select_set(True)
  868. before = set(bpy.data.objects)
  869. bpy.ops.object.duplicates_make_real()
  870. after = set(bpy.data.objects)
  871. realised = list(after - before)
  873. for r in realised:
  874. r.select_set(True)
  875. bpy.context.view_layer.objects.active = realised[0]
  876. bpy.ops.object.join()
  877. joined_obj = bpy.context.selected_objects[0]
  878. joined_obj.name = bulletproof_name(name)
  880. bpy.data.objects.remove(mesh_object, do_unlink=True)
  881. bpy.data.objects.remove(reference_object, do_unlink=True)
  883. frame_selected()
  885. return joined_obj
  888. def voxels_from_coordinates_GN(coordinates, values = None, colour = None, voxel_size = 50):
  889. """
  890. creates a blender object from a set of voxel coordinates, using blender geometry nodes for speed-ups with large numbers of points.
  893. coordinates (Nx3 array): coordinates of interest.
  894. values (array of length N, optional): list of values for each voxel. Mapped to alpha value.
  895. colour (RGBA, optional): colour to render mesh in. If not specfied a random colour will be generated.
  896. voxel_size (float, optional): voxel size in blender space. Default: 50.
  898. returns:
  899. obj (bpy.types.Object): blender mesh object.
  900. """
  902. if not colour:
  903. colour = random_RGBA()
  904. else:
  905. assert len(colour) == 4, "colour must RGBA"
  908. if len(values) != len(coordinates):
  909. values = np.ones(shape = [1, len(coordinates)])
  912. mesh = bpy.data.meshes.new("VoxelPointsMesh")
  913. mesh.from_pydata(coordinates, [], [])
  914. mesh.update()
  916. attr = mesh.attributes.new(
  917. name="value",
  918. type='FLOAT',
  919. domain='POINT'
  920. )
  922. for idx, v in enumerate(values):
  923. attr.data[idx].value = float(v)
  925. obj = bpy.data.objects.new("VoxelPoints", mesh)
  926. bpy.context.collection.objects.link(obj)
  928. mod = obj.modifiers.new(name="VoxelGN", type='NODES')
  929. ng = bpy.data.node_groups.new("VoxelNodeTree", 'GeometryNodeTree')
  930. mod.node_group = ng
  932. ng.interface.new_socket("Geometry", in_out='INPUT', socket_type='NodeSocketGeometry')
  933. ng.interface.new_socket("Geometry", in_out='OUTPUT', socket_type='NodeSocketGeometry')
  935. nodes = ng.nodes
  936. links = ng.links
  937. nodes.clear()
  939. group_in = nodes.new("NodeGroupInput")
  940. group_out = nodes.new("NodeGroupOutput")
  941. named_attr = nodes.new("GeometryNodeInputNamedAttribute")
  942. capture = nodes.new("GeometryNodeCaptureAttribute")
  943. inst = nodes.new("GeometryNodeInstanceOnPoints")
  944. cube = nodes.new("GeometryNodeMeshCube")
  945. store_color = nodes.new("GeometryNodeStoreNamedAttribute")
  946. realize = nodes.new("GeometryNodeRealizeInstances")
  947. combine_color = nodes.new("FunctionNodeCombineColor")
  949. cube.inputs["Size"].default_value = [voxel_size]*3
  951. named_attr.data_type = 'FLOAT'
  952. named_attr.inputs["Name"].default_value = "value"
  954. capture.data_type = 'FLOAT'
  955. capture.domain = 'POINT'
  957. store_color.data_type = 'BYTE_COLOR'
  958. store_color.domain = 'CORNER'
  959. store_color.inputs["Name"].default_value = "Color"
  961. combine_color.inputs["Red"].default_value = colour[0]
  962. combine_color.inputs["Green"].default_value = colour[1]
  963. combine_color.inputs["Blue"].default_value = colour[2]
  965. links.new(group_in.outputs["Geometry"], capture.inputs["Geometry"])
  966. links.new(named_attr.outputs["Attribute"], capture.inputs["Value"])
  967. links.new(capture.outputs["Geometry"], inst.inputs["Points"])
  968. links.new(cube.outputs["Mesh"], inst.inputs["Instance"])
  969. links.new(inst.outputs["Instances"], realize.inputs["Geometry"])
  970. links.new(realize.outputs["Geometry"], store_color.inputs["Geometry"])
  971. links.new(capture.outputs["Attribute"], combine_color.inputs["Alpha"])
  972. links.new(combine_color.outputs["Color"], store_color.inputs["Value"])
  973. links.new(store_color.outputs["Geometry"], group_out.inputs["Geometry"])
  975. # Apply the modifier
  976. bpy.context.view_layer.objects.active = obj
  977. bpy.ops.object.modifier_apply(modifier="VoxelGN")
  979. obj.data.materials.clear()
  981. material = bpy.data.materials.new(name="mat")
  982. material.use_nodes = True
  983. material.blend_method = 'BLEND'
  984. material.shadow_method = 'CLIP'
  986. mat_nodes = material.node_tree.nodes
  987. mat_links = material.node_tree.links
  989. color_attr_node = mat_nodes.new("ShaderNodeVertexColor")
  990. color_attr_node.layer_name = "Color"
  992. pbsdf_node = mat_nodes["Principled BSDF"]
  993. pbsdf_node.inputs["Metallic"].default_value = 0
  994. pbsdf_node.inputs["Roughness"].default_value = 0.5
  995. pbsdf_node.inputs["Base Color"].default_value = (colour[0], colour[1], colour[2], 1.0)
  997. mat_links.new(color_attr_node.outputs["Alpha"], pbsdf_node.inputs["Alpha"])
  999. obj.data.materials.append(material)
  1001. for poly in obj.data.polygons:
  1002. poly.material_index = 0
  1004. bpy.ops.object.select_all(action='DESELECT')
  1005. obj.select_set(True)
  1006. bpy.context.view_layer.objects.active = obj
  1007. bpy.ops.object.shade_smooth()
  1009. return obj
  1012. def draw_spheres(
  1013. coordinates, name=None, colour=None, radius=7, res=1, alpha=1, scale_f=1e6
  1014. ):
  1015. """
  1016. illustrate coordinates as spheres.
  1018. coordinates (Nx3 list of floats): coordinates of locations.
  1019. name (str, optional): name of group for blender.
  1020. colour (RGBA, optional): colour to draw spheres in.
  1021. radius (float, optional): radius of spheres. Default: 7.
  1022. res (float, optional): resolution of spheres. Higher resolution can be slow. Default: 1.
  1023. alpha (float, optional): alpha value (transparency) for material. Must be in the interval [0,1]. Default: 1.
  1024. scale_f (float, optional): scaling factor for coordinates to blender space. Default: 1e6.
  1026. returns:
  1027. obj (bpy.types.Object): blender mesh object of spheres.
  1028. """
  1030. if not colour:
  1031. colour = random_RGBA()
  1032. else:
  1033. assert len(colour) == 4, "colour must RGBA"
  1035. material = bpy.data.materials.new(name="mat")
  1036. material.use_nodes = True
  1037. pbsdf_node = material.node_tree.nodes["Principled BSDF"]
  1038. pbsdf_node.inputs["Base Color"].default_value = colour
  1039. pbsdf_node.inputs["Alpha"].default_value = alpha
  1040. bpy.ops.mesh.primitive_uv_sphere_add(
  1041. location=[0, 0, 0],
  1042. radius=radius,
  1043. segments=int(8 * res),
  1044. ring_count=int(8 * res),
  1045. )
  1046. reference_sphere = bpy.context.selected_objects[0]
  1047. reference_sphere.data.materials.append(material)
  1049. mesh_object = mesh_from_coordinates(
  1050. coordinates, name=name, reference_object=reference_sphere, scale_f=scale_f
  1051. )
  1053. return mesh_object
  1056. def draw_hypervoxels(
  1057. hypervoxel_coords,
  1058. hypervoxel_side_length=300.0,
  1059. colour=(0, 0, 0, 1),
  1060. alpha=1,
  1061. thickness=30,
  1062. scale_f=1e6,
  1063. ):
  1064. """
  1065. draw hypervoxels as skeleton cubes.
  1066. OBS: Snudda hypervoxel coordinates are available through SnuddaDetect, but, by default, are not written to disk.
  1068. hypervoxel_coords (Nx3 list of floats): coordinates of hypervoxel centers.
  1069. hypervoxel_side_length (float): size of hypervoxels.
  1070. colour (RGBA, optional): Colour to render hypervoxels in. If not specfied a random colour will be generated.
  1071. alpha (float, optional): alpha value (transparency) for material. Must be in the interval [0,1]. Default: 1.
  1072. thickness (float, optional): Thickness of wireframe.
  1073. scale_f (float, optional): scaling factor for coordinates to blender space. Default: 1e6.
  1075. returns:
  1076. obj (bpy.types.Object): blender mesh object of hypervoxels.
  1077. """
  1079. center = [hypervoxel_side_length / 2] * 3
  1080. bpy.ops.mesh.primitive_cube_add(location=center, size=hypervoxel_side_length)
  1082. material = bpy.data.materials.new(name="vox_mat")
  1083. material.use_nodes = True
  1084. pbsdf_node = material.node_tree.nodes["Principled BSDF"]
  1085. pbsdf_node.inputs["Base Color"].default_value = colour
  1086. pbsdf_node.inputs["Metallic"].default_value = 0
  1087. pbsdf_node.inputs["Roughness"].default_value = 1
  1088. pbsdf_node.inputs["Specular IOR Level"].default_value = 0
  1089. pbsdf_node.inputs["Alpha"].default_value = alpha
  1090. material.blend_method = "BLEND"
  1092. reference_cube = bpy.context.selected_objects[0]
  1093. reference_cube.data.materials.append(material)
  1094. reference_cube.name = "hypervoxel"
  1096. mod = reference_cube.modifiers.new(name="wf", type="WIREFRAME")
  1097. mod.thickness = thickness
  1098. mod.use_replace = True
  1099. bpy.ops.object.modifier_apply(modifier="wf")
  1101. hypervoxel_coords = np.array(hypervoxel_coords) * scale_f
  1102. mesh = mesh_from_coordinates(
  1103. coordinates=hypervoxel_coords,
  1104. name="hypervoxels",
  1105. reference_object=reference_cube,
  1106. )
  1108. return mesh
  1111. ##################################
  1112. #### Snudda specfic functions ####
  1113. ##################################
  1115. ### Note: tested with Snudda SNr branch only. For virtual synapses: synapse location must be saved in input hdf5 file.
  1116. ### OBS: this is not default snudda behaviour.
  1117. ### Snudda uses microns at some points, and meters at others. Adjust scale_f depending on use case.
  1120. def draw_neuron_from_snudda(
  1121. neurons, neuron_id, snudda_data, name=None, colour=None, scale_f=1e6
  1122. ):
  1123. """ "
  1124. draws specified neuron from snudda network.
  1125. neurons (list of dicts): data from snudda network: ie., sl.data['neurons'].
  1126. neuron_id (int): id of neuron to draw.
  1127. name (str, optional): name of neuron for blender.
  1128. colour (RGBA, optional): Colour to render neuron in. If not specfied a random colour will be generated.
  1129. scale_f (float, optional): Scaling factor for coordinates to blender space. Default: 1e6.
  1131. returns:
  1132. obj (bpy.types.Object): blender mesh object of neuron.
  1133. """
  1135. if not colour:
  1136. colour = random_RGBA()
  1137. else:
  1138. assert len(colour) == 4, "colour must RGBA"
  1140. position = neurons[neuron_id]["position"] * scale_f
  1141. e_rot = mathutils.Matrix(neurons[neuron_id]["rotation"].reshape(3, 3)).to_euler()
  1143. build_from_swc(
  1144. snudda_parse_path(neurons[neuron_id]["morphology"], snudda_data),
  1145. name=name,
  1146. lx=position[0],
  1147. ly=position[1],
  1148. lz=position[2],
  1149. colour=colour,
  1150. )
  1152. obj = bpy.context.selected_objects[0]
  1153. obj.rotation_euler = e_rot
  1155. return obj
  1158. def draw_postsynaptic(
  1159. network_path,
  1160. post_id,
  1161. snudda_data,
  1162. draw_presynaptic_partners=True,
  1163. draw_synapses=True,
  1164. scale_f=1e6,
  1165. post_colour=(239 / 255, 42 / 255, 126 / 255, 1.0),
  1166. pre_colour=None,
  1167. synapse_colour=None,
  1168. synapse_radius=5,
  1169. match_synapses=False,
  1170. ):
  1171. """
  1172. draws postsynaptic neuron with (optionally) presynaptic partners and/or synapse locations.
  1174. network_path (str): path to snudda network-synapses.hdf5 file.
  1175. post_id (int): id of neuron to analyse and draw.
  1176. snudda_data (str): path to snudda data.
  1177. draw_presynaptic_partners (bool, optional): If True, presynaptic neurons will also be drawn.
  1178. draw_synapses (bool, optional): If True, afferent synapses of post_id will be drawn.
  1179. scale_f (float, optional): Scaling factor for coordinates to blender space. Default: 1e6.
  1180. pre_colour (RGBA, optional): Colour to draw postsynaptic neuron in. Default: (239/255, 42/255, 126/255, 1.0) - kind of a red-pink colour. I am colourblind though, so don't trust that...
  1181. post_colour (RGBA, optional): Colour to draw presynaptic neurons in.
  1182. synapse_colour (RGBA, optional): Colour to draw synapses in.
  1183. synapse_radius (float, optional): Radius of synapses. Default: 5.
  1186. returns:
  1188. pre_ids (list): list of presynaptic partner ids.
  1189. post_synapse_coords (list): list of afferent synapse coordinates.
  1191. """
  1193. sl = SnuddaLoad(os.path.join(network_path, "network-synapses.hdf5"))
  1194. neurons = sl.data["neurons"]
  1195. synapses = sl.data["synapses"]
  1196. synapse_coords = sl.data["synapse_coords"]
  1197. post_synapses = (synapses[:, 1] == post_id).astype(bool)
  1198. pre_ids = list(set(synapses[post_synapses, 0]))
  1199. pre_synapse_coords = synapse_coords[post_synapses]
  1201. draw_neuron_from_snudda(
  1202. neurons,
  1203. post_id,
  1204. snudda_data,
  1205. name="postsynaptic" + str(post_id),
  1206. colour=post_colour,
  1207. )
  1209. if not match_synapses:
  1211. if draw_presynaptic_partners:
  1212. for pre_id in pre_ids:
  1213. draw_neuron_from_snudda(
  1214. neurons,
  1215. pre_id,
  1216. snudda_data,
  1217. name="presynaptic" + str(pre_id),
  1218. colour=pre_colour,
  1219. )
  1221. if draw_synapses:
  1223. if not synapse_colour:
  1224. synapse_colour = random_RGBA()
  1225. else:
  1226. assert len(synapse_colour) == 4, "colour must RGBA"
  1228. material = bpy.data.materials.new(name="syn_mat")
  1229. material.use_nodes = True
  1230. pbsdf_node = material.node_tree.nodes["Principled BSDF"]
  1231. pbsdf_node.inputs["Base Color"].default_value = synapse_colour
  1232. bpy.ops.mesh.primitive_uv_sphere_add(
  1233. location=[0, 0, 0], radius=synapse_radius, segments=16, ring_count=16
  1234. )
  1235. reference_sphere = bpy.context.selected_objects[0]
  1236. reference_sphere.data.materials.append(material)
  1238. mesh_from_coordinates(
  1239. pre_synapse_coords,
  1240. name="synapses",
  1241. reference_object=reference_sphere,
  1242. scale_f=scale_f,
  1243. )
  1245. else:
  1247. for pre_id in pre_ids:
  1249. matched_synapses = (
  1250. (synapses[:, 0] == pre_id) & (synapses[:, 1] == post_id)
  1251. ).astype(bool)
  1253. colour = random_RGBA(low=0, high=255)
  1254. draw_neuron_from_snudda(
  1255. neurons,
  1256. pre_id,
  1257. snudda_data,
  1258. name="presynaptic" + str(pre_id),
  1259. colour=colour,
  1260. )
  1262. material = bpy.data.materials.new(name="syn_mat")
  1263. material.use_nodes = True
  1264. pbsdf_node = material.node_tree.nodes["Principled BSDF"]
  1265. pbsdf_node.inputs["Base Color"].default_value = colour
  1266. bpy.ops.mesh.primitive_uv_sphere_add(
  1267. location=[0, 0, 0], radius=synapse_radius, segments=16, ring_count=16
  1268. )
  1269. reference_sphere = bpy.context.selected_objects[0]
  1270. reference_sphere.data.materials.append(material)
  1272. mesh_from_coordinates(
  1273. synapse_coords[matched_synapses],
  1274. name="synapses" + str(pre_id),
  1275. reference_object=reference_sphere,
  1276. scale_f=scale_f,
  1277. )
  1279. return pre_ids, pre_synapse_coords
  1282. def draw_presynaptic(
  1283. network_path,
  1284. pre_id,
  1285. snudda_data,
  1286. draw_postsynaptic_partners=True,
  1287. draw_synapses=True,
  1288. scale_f=1e6,
  1289. pre_colour=(239 / 255, 42 / 255, 126 / 255, 1.0),
  1290. post_colour=None,
  1291. synapse_colour=None,
  1292. synapse_radius=5,
  1293. ):
  1294. """
  1295. draws presynaptic neuron with (optionally) postsynaptic partners and/or synapse locations.
  1297. network_path (str): path to snudda network-synapses.hdf5 file.
  1298. pre_id (int): id of neuron to draw.
  1299. snudda_data (str): path to snudda data.
  1300. draw_postsynaptic_partners (bool, optional): If True, postsynaptic neurons will also be drawn.
  1301. draw_synapses (bool, optional): If True, efferent synapses of pre_id will be drawn.
  1302. scale_f (float, optional): Scaling factor for coordinates to blender space. Default: 1e6.
  1303. pre_colour (RGBA, optional): Colour to draw presynaptic neuron in. Default: (239/255, 42/255, 126/255, 1.0) - kind of a red-pink colour. I am colourblind though, so don't trust that...
  1304. post_colour (RGBA, optional): Colour to draw postsynaptic neurons in.
  1305. synapse_colour (RGBA, optional): Colour to draw synapses in.
  1306. synapse_radius (float, optional): Radius of synapses. Default: 5.
  1308. returns:
  1310. post_ids (list): list of postsynaptic partner ids.
  1311. pre_synapse_coords (list): list of efferent synapse coordinates.
  1313. """
  1315. sl = SnuddaLoad(os.path.join(network_path, "network-synapses.hdf5"))
  1316. neurons = sl.data["neurons"]
  1317. synapses = sl.data["synapses"]
  1318. synapse_coords = sl.data["synapse_coords"]
  1320. post_synapses = (synapses[:, 0] == pre_id).astype(bool)
  1321. post_ids = list(set(synapses[post_synapses, 1]))
  1322. pre_synapse_coords = synapse_coords[post_synapses]
  1324. draw_neuron_from_snudda(
  1325. neurons,
  1326. pre_id,
  1327. snudda_data,
  1328. name="presynaptic" + str(pre_id),
  1329. colour=pre_colour,
  1330. )
  1332. if draw_postsynaptic_partners:
  1333. for post_id in post_ids:
  1334. draw_neuron_from_snudda(
  1335. neurons,
  1336. post_id,
  1337. snudda_data,
  1338. name="postynaptic" + str(post_id),
  1339. colour=post_colour,
  1340. )
  1342. if draw_synapses:
  1343. if not synapse_colour:
  1344. synapse_colour = pre_colour
  1345. else:
  1346. assert len(synapse_colour) == 4, "colour must RGBA"
  1348. material = bpy.data.materials.new(name="syn_mat")
  1349. material.use_nodes = True
  1350. pbsdf_node = material.node_tree.nodes["Principled BSDF"]
  1351. pbsdf_node.inputs["Base Color"].default_value = synapse_colour
  1352. bpy.ops.mesh.primitive_uv_sphere_add(
  1353. location=[0, 0, 0], radius=synapse_radius, segments=16, ring_count=16
  1354. )
  1355. reference_sphere = bpy.context.selected_objects[0]
  1356. reference_sphere.data.materials.append(material)
  1358. mesh_from_coordinates(
  1359. pre_synapse_coords,
  1360. name="synapses",
  1361. reference_object=reference_sphere,
  1362. scale_f=scale_f,
  1363. )
  1365. return post_ids, pre_synapse_coords
  1368. def add_virtual_input_locations(
  1369. coords,
  1370. neuron,
  1371. location=[0, 0, 0],
  1372. rotation=[0, 0, 0],
  1373. name=None,
  1374. scale_f=1,
  1375. soma_radius=10,
  1376. colour=None,
  1377. radius=4,
  1378. res=1,
  1379. jitter_amount=None,
  1380. timing=None,
  1381. ):
  1382. """
  1383. renders synapses at input locations defined in snudda input file (ie., virtual inputs).
  1385. coords (Nx3 array): input locations.
  1386. neuron (snudda neuron class, optional): postsynaptic neuron. Overrides location and rotation if passed.
  1387. location (1x3 array, optional): location to center coordinates.
  1388. rotation (1x3 array, optional): rotation of coordinates in Euler format (XYZ).
  1389. name (str, optional): name of synapse group for blender.
  1390. scale_f (float, optional): Scaling factor for coordinates to blender space. Default: 1 (ie., 1:1).
  1391. soma_radius (float, optional): Radius of soma. Synapses within this distance are randomly offset to the soma surface.
  1392. colour (RGBA, optional): Colour to render synapses in. If not specfied a random colour will be generated.
  1393. radius (float, optional): Radius for synapse representaiton.
  1394. res (float, optional): Resolution of synapse spheres. Higher resolution can be slow. Default: 1.
  1395. jitter_amount (float, optional): Jitter to be applied to synapse coordinates. Offsets synapses from dendrites for aesthetic purposes.
  1396. timing (int, optional): If specified, synapses will be animated to appear (ie., rain in) at the given time (keyframe). Can become very slow, as each synapse will be rendered individually.
  1398. """
  1400. coords = np.array(coords) * scale_f
  1402. distances = np.linalg.norm(coords, axis=1)
  1403. inside_soma = distances < soma_radius
  1404. coords[inside_soma] = soma_radius * spherical_sample(np.sum(inside_soma))
  1406. if jitter_amount:
  1407. jitter = np.random.uniform(-jitter_amount, jitter_amount, coords.shape)
  1408. coords += jitter
  1410. if not colour:
  1411. colour = random_RGBA()
  1412. else:
  1413. assert len(colour) == 4, "colour must RGBA"
  1415. material = bpy.data.materials.new(name=str(name) + "_mat")
  1416. material.use_nodes = True
  1417. pbsdf_node = material.node_tree.nodes["Principled BSDF"]
  1418. pbsdf_node.inputs["Metallic"].default_value = 0
  1419. pbsdf_node.inputs["Roughness"].default_value = 0.5
  1420. pbsdf_node.inputs["Base Color"].default_value = colour
  1422. if neuron:
  1423. rotation = mathutils.Matrix(neuron["rotation"].reshape(3, 3)).to_euler()
  1424. location = neuron["position"] * scale_f
  1426. if timing:
  1427. for c in coords:
  1428. bpy.ops.mesh.primitive_uv_sphere_add(
  1429. location=[0, 0, 0],
  1430. radius=radius,
  1431. segments=int(8 * res),
  1432. ring_count=int(8 * res),
  1433. )
  1434. sphere = bpy.context.selected_objects[0]
  1435. sphere.data.materials.append(material)
  1436. rotated_coord = rotation.to_matrix() @ mathutils.Vector(c)
  1437. sphere.location = [0, 0, 0]
  1438. sphere.keyframe_insert(
  1439. data_path="location", frame=1, options={"INSERTKEY_NEEDED"}
  1440. )
  1441. sphere.location = rotated_coord + mathutils.Vector(location)
  1442. sphere.keyframe_insert(
  1443. data_path="location",
  1444. frame=random.randint(timing - 5, timing + 5),
  1445. options={"INSERTKEY_NEEDED"},
  1446. )
  1448. if sphere.animation_data and sphere.animation_data.action:
  1449. for fcurve in sphere.animation_data.action.fcurves:
  1450. if fcurve.data_path == "location":
  1451. for keyframe in fcurve.keyframe_points:
  1452. keyframe.interpolation = "BEZIER"
  1453. keyframe.easing = "EASE_OUT"
  1454. else:
  1455. bpy.ops.mesh.primitive_uv_sphere_add(
  1456. location=[0, 0, 0],
  1457. radius=radius,
  1458. segments=int(8 * res),
  1459. ring_count=int(8 * res),
  1460. )
  1461. reference_sphere = bpy.context.selected_objects[0]
  1462. reference_sphere.data.materials.append(material)
  1464. mesh = mesh_from_coordinates(coords, reference_object=reference_sphere)
  1466. if neuron:
  1467. rotation = mathutils.Matrix(neuron["rotation"].reshape(3, 3)).to_euler()
  1468. location = neuron["position"] * scale_f
  1470. mesh.rotation_euler = rotation
  1471. mesh.location = location
  1473. return
  1476. def virtual_synapse_coordinates(input_file, neuron_id, input_prefix, snudda_data):
  1477. """
  1478. returns coordinates of synapses for specified postsynapic neuron_ids. OBS: make sure you are saving locations when you generate input, otherwise there will be no locations to find...
  1480. input_file (str): path to snudda input file (.hdf5).
  1481. neuron_id (int or list of ints): postsynaptic neuron id(s).
  1482. input_prefix (str or list of strs): prefix for input types of interest ('STN' for example).
  1483. snudda_data (str): path to snudda data folder.
  1485. returns:
  1486. syn_dict (dict): nested dictionary. Top level keys: neuron ids. Lower level keys: input_prefix. Values: lists of coordinates.
  1488. """
  1490. if isinstance(neuron_id, int):
  1491. neuron_id = [neuron_id]
  1492. if isinstance(input_prefix, str):
  1493. input_prefix = [input_prefix]
  1495. input_data = h5py.File(snudda_parse_path(input_file, snudda_data), "r")
  1496. syn_dict = {}
  1497. for n_id in neuron_id:
  1498. neuron_dict = {}
  1499. n_id = str(n_id)
  1500. if n_id in input_data["input"].keys():
  1501. for i_p in input_prefix:
  1502. syns = []
  1503. for k in input_data["input"][n_id].keys():
  1504. if i_p in k:
  1505. syns.append(input_data["input"][n_id][k]["location"][()])
  1506. neuron_dict[i_p] = syns
  1507. syn_dict[n_id] = neuron_dict
  1509. return syn_dict
  1512. ##########################################################################################################################################################################
  1514. if __name__ == "__main__":
  1515. print(
  1516. "Do not run this file directly. Call functions from python within blender please!"
  1517. )
  1518. sys.exit(-1)

bb_tools.py at commit 5226424, under GPL-3.0 · at the source

Overview

Authors: William Scott Thompson1, Patryk Wekwejt1, Sten Grillner1, Gilad Silberberg1
ORCID iDs: William Scott Thompson, Sten Grillner, Gilad Silberberg
  1. Department of Neuroscience, Karolinska Institutet, Stockholm, Sweden
Institutions: Karolinska Institutet (Sweden)
Journal: Nature communications, volume 17, issue 1, article 5551
Dates: received 11 February 2025; accepted 8 June 2026; published online 23 June 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1038/s41467-026-74569-w · PMID 42336891 · PMCID PMC13291323 · OpenAlex W7165632366
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: intracellular / patch clamp (modality), mouse (organism), systems (subfield)
Methods: Smoothing, state filtering, decompositions, Machine learning, Spectral & time-frequency
Keywords: Basal ganglia, Motor cortex
MeSH: Basal Ganglia*, Motor Cortex*, Pars Reticulata*, Animals, GABAergic Neurons, Mice, Neurons, Optogenetics, Patch-Clamp Techniques, Substantia Nigra (* major topic)
Topic: Neural dynamics and brain function (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Hjärnfonden (FO2023-0230); Knut och Alice Wallenbergs Stiftelse (Knut and Alice Wallenberg Foundation) (KAW 2017.0273); Vetenskapsrådet (VR-M-2019-01854, VR-M-2019-01254, VR-M-2023-02304)
Citations: cited by 3 papers (Europe PMC); 94 references in the paper

Abstract

Inhibitory neurons of the substantia nigra pars reticulata (SNr) serve as a primary output through which the basal ganglia regulate behavior. Using a virally targeted optogenetic approach, combined with whole cell patch-clamp recordings of SNr neurons, we show that, in mice, projection neurons of both primary and secondary motor cortices (M1 and M2) form monosynaptic excitatory connections onto different subpopulations of GABAergic SNr neurons. Furthermore, photostimulation of these cortical axon terminals markedly increases SNr neuron firing rate. To investigate the spatial organization of cortical input to the SNr, we employed a transsynaptic viral-labelling approach to identify SNr neurons receiving monosynaptic input from either M1 or M2. We found a topographical organization of the M1 and M2 projections in SNr. Chemogenetic inhibition of M1- and M2-targeted SNr neurons induced opposing changes in spontaneous behavior. These findings reveal functional pathways by which the motor cortex can directly modulate basal ganglia output to downstream targets.

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

Repository

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

wstho/brainblenda

License: GPL-3.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 52264246d149cba6983cdf7bf4d5d4ec1b520dbc, 18 March 2026
Languages: Jupyter (2), Python (1)
Size: 182 files, 3 scripts
Software Heritage: not checked
Found in: “Code availability”
Holds: README, license file, 1 notebook
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: h5py (3 files), NumPy (3 files), pandas (2 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
5 files
At the source: github.com/wstho/brainblenda

Code availability

Visualization code is available at https://github.com/wstho/brainblenda. Additional code used in this study will be made available upon request.

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

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;
  • 3 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

A source data file supporting the findings of this study is provided with this paper. Further data will be made available upon request. Source data are provided with this paper.

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, issue, pages, dates, 4 authors, 2 keywords, 10 MeSH terms, 3 funders, 93 references.

Cite

This paper

Thompson, W. S., Wekwejt, P., Grillner, S., & Silberberg, G. (2026). Motor cortex directly excites the substantia nigra pars reticulata, the basal ganglia output nucleus. Nature communications, 17(1), 5551. https://doi.org/10.1038/s41467-026-74569-w

BibTeX

@article{thompson2026motor,
author = {Thompson, William Scott and Wekwejt, Patryk and Grillner, Sten and Silberberg, Gilad},
title = {{Motor cortex directly excites the substantia nigra pars reticulata, the basal ganglia output nucleus}},
journal = {Nature communications},
year = {2026},
month = jun,
volume = {17},
number = {1},
pages = {5551},
publisher = {Nature Publishing Group},
issn = {2041-1723},
doi = {10.1038/s41467-026-74569-w},
url = {https://doi.org/10.1038/s41467-026-74569-w},
pmid = {42336891},
pmcid = {PMC13291323}
}

RIS

TY - JOUR
AU - Thompson, William Scott
AU - Wekwejt, Patryk
AU - Grillner, Sten
AU - Silberberg, Gilad
TI - Motor cortex directly excites the substantia nigra pars reticulata, the basal ganglia output nucleus
T2 - Nature communications
J2 - Nat Commun
PY - 2026
DA - 2026/06/23
VL - 17
IS - 1
SP - 5551
SN - 2041-1723
PB - Nature Publishing Group
DO - 10.1038/s41467-026-74569-w
UR - https://doi.org/10.1038/s41467-026-74569-w
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41467-026-74569-w",
"type": "article-journal",
"title": "Motor cortex directly excites the substantia nigra pars reticulata, the basal ganglia output nucleus",
"container-title": "Nature communications",
"author": [
{
"family": "Thompson",
"given": "William Scott"
},
{
"family": "Wekwejt",
"given": "Patryk"
},
{
"family": "Grillner",
"given": "Sten"
},
{
"family": "Silberberg",
"given": "Gilad"
}
],
"container-title-short": "Nat Commun",
"volume": "17",
"issue": "1",
"page": "5551",
"DOI": "10.1038/s41467-026-74569-w",
"PMID": "42336891",
"PMCID": "PMC13291323",
"ISSN": "2041-1723",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41467-026-74569-w",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
23
]
]
}
}

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.7554/elife.109240 [code]
Neural activity profiles reveal overlapping, intermingled subpopulations spanning area borders in mouse sensorimotor cortex.
Journal: eLife
In common: systems, mouse, 10 references
[2] doi:10.7554/elife.111876 [code]
Distinct sensorimotor encoding in tuft dendrites and somata associated with action, correction, and learning.
Journal: eLife
In common: pandas, NumPy, mouse, 7 references
[3] doi:10.1038/s41467-026-73476-4 [code]
Developmental molecular signatures define de novo cortico-brainstem circuit for skilled forelimb movement.
Journal: Nature communications
In common: pandas, NumPy, mouse, 7 references
[4] doi:10.1371/journal.pbio.3003749
Somatosensory input drives membrane potential dynamics in motor cortex during voluntary limb movement.
Journal: PLoS biology
In common: intracellular / patch clamp, systems, mouse, 6 references
[5] doi:10.1016/j.celrep.2026.117419 [code]
Conserved role of primary motor cortex in the control of prehension in mice and macaques.
Journal: Cell reports
In common: pandas, NumPy, systems, mouse, 6 references
[6] doi:10.1038/s41593-026-02253-9 [code]
Genoarchitecture and input-output organization of the mouse basal ganglia and thalamic parafascicular nucleus.
Journal: Nature neuroscience
In common: h5py, pandas, NumPy, mouse, 4 references
[7] doi:10.1016/j.stemcr.2026.103015 [code]
Brain injury reactivates a developmental program driving genesis and integration of transient LGE-class interneurons.
Journal: Stem cell reports
In common: h5py, pandas, NumPy, mouse, 3 references
[8] doi:10.1038/s41467-026-71426-8 [code]
Distinct modes of dopamine modulation on striatopallidal synaptic transmission.
Journal: Nature communications
In common: pandas, NumPy, intracellular / patch clamp, mouse, 3 references
[9] doi:10.1038/s41467-026-77168-x [code]
Cholinergic-dependent dopamine signals in mouse dorsomedial striatum are regulated by frontal but not sensory cortices.
Journal: Nature communications
In common: h5py, pandas, NumPy, systems, mouse, 2 references
[10] doi:10.1371/journal.pbio.3003687 [code]
Glutamatergic projections from the substantia nigra pars reticulata to the dorsal raphe nucleus regulate male social hierarchies.
Journal: PLoS biology
In common: systems, mouse, 4 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.