OSCR

Curvature-based machine-learning method for automated segmentation of dendritic spines.

Code ↔ Paper

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

The 7 matches
  1. [1] § Results › Dendritic spine morphologic parameters ↔ dend_analysis/dend_fun_0/get_path.py, lines 1977–2061 · score 0.70 · head diameter, neck diameter, spine volume, spine area, spine length, histograms
  2. [2] § Materials and methods › DNN approach for spine and shaft analysis › Skeletonization ↔ dend_analysis/dend_fun_0/get_wrap.py, lines 92–128 · score 0.68 · sampled point cloud, orients normals, Poisson, wrap, reconstruction, geometric
  3. [3] § Materials and methods › DNN approach for spine and shaft analysis ↔ dend_analysis/dend_fun_0/side_bar.py, lines 493–574 · score 0.67 · informed neural network, Machine learning, architectures, CNNs, DNN, geometrical
  4. [4] § Materials and methods › DNN approach for spine and shaft analysis › Skeletonization ↔ dend_analysis/dend_fun_2/help_pinn_data_222.py, lines 46–67 · score 0.65 · sampled point cloud, orients normals, Poisson, wrap, geometric, mesh
  5. [5] § Materials and methods › DNN approach for spine and shaft analysis › Dendrite spine-shaft segmentation using dendritic-branch regions (DNN3) ↔ dend_analysis/main.ipynb, lines 330–435 · score 0.55 · gauss sq, length sh, kmean, vert, skl, distance
  6. [6] § Materials and methods › Dataset description › Training dataset ↔ dend_analysis/dend_fun_0/help_pinn_data_fun.py, lines 494–589 · score 0.52 · KD tree, radius threshold, map, neighbor, branch, vertices
  7. [7] § Materials and methods › Dataset description › Training dataset ↔ dend_analysis/dend_fun_2/help_pinn_data_222.py, lines 391–520 · score 0.52 · KD tree, radius threshold, map, neighbor, branch, vertices

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,253 lines · 66 KB · no license · 2 matches

  3. import sys
  4. import os
  5. import numpy as np
  7. os.environ["TF_ENABLE_ONEDNN_OPTS"] = "0"
  8. import numpy as np
  9. import tensorflow as tf
  10. tf.config.run_functions_eagerly(True)
  11. DTYPE='float32'
  12. import pickle
  13. from dend_fun_0.curvature import curv_mesh as curv_mesh
  14. import dend_fun_0.help_funn as hff
  15. from dend_fun_0.help_funn import dendrite, cluster_class,label_cluster,Branch_division,get_intensity,Threshold_curv,Impute_intensity, order_points_along_pca
  16. from dend_fun_0.help_funn import mappings_vertices,clust_pca,dendrite_io,volume,closest_distances_group,find_min_max_no_cross,Curve_length
  18. DTYPE = tf.float32
  20. from sklearn.neighbors import KDTree
  22. from dend_fun_0.obj_get import Obj_to_vertices,get_obj_filenames_with_indices_2
  23. from dend_fun_2.metric import center_curvature, get_kmean,get_kmean_mean ,get_center_lines
  24. from dend_fun_0.help_pinn_data_fun import get_model,model_shaft,pinn_data_init
  25. device = "/GPU:0" if tf.config.list_physical_devices('GPU') else "/CPU:0"
  27. from dend_fun_0.help_spine_division import region_branch
  30. import random
  31. np.random.seed(42)
  32. tf.random.set_seed(42)
  33. random.seed(42)
  37. from collections import defaultdict
  38. import trimesh
  39. from scipy.spatial import KDTree
  40. import open3d as o3d
  42. from skimage.measure import label
  43. from skimage.morphology import skeletonize
  44. from scipy.ndimage import label
  46. def get_wrap(vertices,faces,number_of_points=8000,radius=0.9, max_nn=30):
  48. mesh = trimesh.Trimesh(vertices=vertices , faces=faces)
  49. o3d_mesh = o3d.geometry.TriangleMesh()
  50. o3d_mesh.vertices = o3d.utility.Vector3dVector(mesh.vertices)
  51. o3d_mesh.triangles = o3d.utility.Vector3iVector(mesh.faces)
  52. pcd = o3d_mesh.sample_points_poisson_disk(number_of_points=number_of_points)
  54. # Estimate and orient normals
  55. pcd.estimate_normals(search_param=o3d.geometry.KDTreeSearchParamHybrid(radius=radius, max_nn=max_nn))
  56. pcd.orient_normals_consistent_tangent_plane(k=10)
  58. mesh_poisson, _ = o3d.geometry.TriangleMesh.create_from_point_cloud_poisson( pcd,
  59. depth=12, # adjust octree depth as needed
  60. width=0, # default
  61. scale=1.1, # default scaling
  62. linear_fit=False,
  63. n_threads=1 ,
  64. )
  67. return np.asarray(mesh_poisson.vertices), np.asarray(mesh_poisson.triangles)
  71. def get_contraction(vertices, skeleton_points, alpha=0.5):
  72. tree = KDTree(skeleton_points)
  73. idx = tree.query(vertices )[1]
  74. nearest_skel = skeleton_points[idx ]
  75. return (1 - alpha) * vertices + alpha * nearest_skel
  78. class mesh_resize():
  79. def __init__(self,vertices,faces,target_number_of_triangles=6000, ):
  80. self.vertices=vertices
  81. mesh = trimesh.Trimesh(vertices=vertices, faces=faces)
  82. o3d_mesh = o3d.geometry.TriangleMesh()
  83. o3d_mesh.vertices = o3d.utility.Vector3dVector(mesh.vertices)
  84. o3d_mesh.triangles = o3d.utility.Vector3iVector(mesh.faces)
  85. o3d_mesh = o3d_mesh.simplify_quadric_decimation(target_number_of_triangles=target_number_of_triangles)
  86. self.mesh = trimesh.Trimesh(
  87. vertices=np.asarray(o3d_mesh.vertices),
  88. faces=np.asarray(o3d_mesh.triangles)
  89. )
  91. def reduce_rhs(self, labels): return labels[KDTree(self.vertices).query(self.mesh.vertices)[1]]
  93. def reduce_to_full_rhs(self, labels): return labels[KDTree(self.mesh.vertices).query(self.vertices)[0]]
  98. class mesh_to_skeleton():
  99. def __init__(self,vertices,faces,target_number_of_triangles=6000,voxel_resolution = 128,tf_largest=False,disp_infos=True,tf_resize=True):
  100. self.vertices=vertices
  101. if tf_resize:
  102. mrs=mesh_resize(vertices,faces,target_number_of_triangles=target_number_of_triangles, )
  103. self.mesh=mrs.mesh
  104. else:
  105. self.mesh = trimesh.Trimesh(
  106. vertices=np.asarray(vertices),
  107. faces=np.asarray(faces)
  108. )
  110. edges = np.median(self.mesh.edges_unique_length) * 0.25
  111. print('mesh_to_skeleton-------edge----------',edges)
  112. voxelized = self.mesh.voxelized(pitch=(edges))
  114. filled = voxelized.fill()
  115. voxels = filled.matrix.astype(bool)
  117. if disp_infos:
  118. print("Voxel grid shape:", voxels.shape,)
  120. # skeleton_voxels = skeletonize_3d(voxels)
  121. skeleton_voxels = skeletonize(voxels)
  122. skeleton_coords = np.argwhere(skeleton_voxels)
  123. if tf_largest:
  124. labeled = label(skeleton_voxels)
  125. largest_label = np.argmax(np.bincount(labeled.flat)[1:]) + 1
  126. skeleton_voxels = labeled == largest_label
  128. if skeleton_coords.size == 0:
  129. print('--------------------',voxel_resolution,target_number_of_triangles)
  130. raise ValueError("No skeleton found — something went wrong in voxelization.")
  132. min_bound = self.mesh.bounds[0]
  133. pitch = filled.pitch
  134. self.skeleton_points = skeleton_coords * pitch + min_bound
  136. tree = KDTree(self.skeleton_points)
  137. distances, self.skl_index = tree.query(vertices)
  138. self.distances=distances
  139. self.dist_norm = (distances - distances.min()) / (distances.max() - distances.min())
  141. def mapping(self):
  142. self.skeleton_to_vertices = defaultdict(list)
  143. for vertex, skl_idx in zip(self.vertices, self.skl_index):
  144. if skl_idx not in self.skeleton_to_vertices:
  145. self.skeleton_to_vertices[skl_idx] = []
  146. self.skeleton_to_vertices[skl_idx].append(vertex)
  148. def mapping_inv(self, skeleton_vec):
  149. if not hasattr(self, 'skeleton_to_vertices'):
  150. self.mapping()
  151. vertices_mapped=[]
  152. for vec in skeleton_vec:
  153. vertices_mapped.extend(self.skeleton_to_vertices[vec])
  154. return vertices_mapped
  157. def reduce_rhs(self, labels): return labels[KDTree(self.vertices).query(self.mesh.vertices)[1]]
  159. def reduce_to_full_rhs(self, labels): return labels[KDTree(self.mesh.vertices).query(self.vertices)[0]]
  164. def def_mesh_to_skeleton_finder(vertices,faces,
  165. interval_voxel_resolution=None,
  166. interval_target_number_of_triangles=None,
  167. tf_largest=False,
  168. disp_infos=True,
  169. min_voxel_resolution=20,
  170. min_target_number_of_triangles=100,
  171. tf_division=False
  173. ):
  174. ktrr=KDTree(vertices)
  175. skss={}
  176. cv=1e100
  177. n_vert=len(vertices)
  178. nskl=None
  179. interval_target_number_of_triangles=interval_target_number_of_triangles if interval_target_number_of_triangles is not None else [1]
  180. if disp_infos:
  181. print('Start mesh_to_skeleton')
  182. print('------------------------------------')
  183. print('interval_target_number_of_triangles =',interval_target_number_of_triangles)
  184. print('interval_voxel_resolution =',interval_voxel_resolution)
  185. print('len(vertices) =',n_vert)
  186. for vv in interval_target_number_of_triangles:
  187. for uu in interval_voxel_resolution:
  188. n_voxel_resolution =uu if not tf_division else max(n_vert//uu,min_voxel_resolution)
  189. target_number_of_triangles =vv if not tf_division else max(n_vert//vv,min_target_number_of_triangles)
  190. print('n_voxel_resolution,target_number_of_triangles =',n_voxel_resolution,target_number_of_triangles)
  191. nskl=mesh_to_skeleton(vertices=vertices,
  192. faces=faces,
  193. voxel_resolution =n_voxel_resolution,
  194. target_number_of_triangles=target_number_of_triangles,
  195. tf_largest=tf_largest,
  196. disp_infos=disp_infos)
  197. distan = ktrr.query(nskl.skeleton_points)[0]
  198. cvtmp= np.std(distan) / np.mean(distan)
  199. if cvtmp<cv:
  200. cv=cvtmp
  201. uutmp=uu
  202. skl=nskl
  203. best_target_number_of_triangles=target_number_of_triangles,vv
  204. best_voxel_resolution=n_voxel_resolution,uu
  205. if disp_infos:
  206. print('The best target_number_of_triangles =',best_target_number_of_triangles)
  207. print('The best voxel_resolution =',best_voxel_resolution)
  208. return skl
  212. def get_model(base_features ,vcv_length, model_sufix, add_param=None ):
  213. vcv_length =np.asarray(vcv_length).reshape(-1, 1)
  214. if model_sufix.startswith("opt"):
  215. base_features.append(hff.normalize(vcv_length) )
  216. return base_features
  221. class mapping_skl():
  222. def __init__(self,vertices,skeleton_points, ):
  223. self.vertices=vertices
  224. tree = KDTree( skeleton_points)
  225. _, skl_index = tree.query(vertices)
  226. self.mappk={}
  227. for fb,vf in zip(skl_index,vertices):
  228. fbv=tuple(skeleton_points[fb])
  229. if fbv not in self.mappk:
  230. self.mappk[fbv]=[]
  231. self.mappk[fbv].append(vf)
  235. def mapping_inv(self, skeleton_points):
  236. vertices_mapped=[]
  237. for fb in skeleton_points:
  238. fbv=tuple(fb)
  239. vertices_mapped.extend(self.mappk[fbv])
  241. return np.array(vertices_mapped)
  249. def get_head_neck_mectric(self,metric_save,metrics,dname, name,spine_index,spine_faces,vertices_index_unique,vertices_center, vertices_head_index_set,vertices_neck_index_set,
  250. subsample_thre=None,
  251. f=None,
  252. N=None,
  253. num_chunks=None,
  254. num_points=None,
  255. line_num_points= None,
  256. line_num_points_inter= None,
  257. spline_smooth= None,
  258. ctl_run_thre=None,
  259. node_neck=None,
  260. node_head=None, ):
  262. metrics['head_diameter'][dname]= 2*metric_save[name]['limit'][0]
  263. metrics['neck_diameter'][dname]= 2*metric_save[name]['limit'][2]
  266. ctl_tmp=get_center_lines(
  267. vertices =self.vertices_00[spine_index],
  268. vertices_center= vertices_center,
  269. subsample_thre=subsample_thre,
  270. f=f,
  271. N=N,
  272. num_chunks=num_chunks,
  273. num_points=num_points,
  274. line_num_points= line_num_points,
  275. line_num_points_inter= line_num_points_inter,
  276. spline_smooth= spline_smooth,
  277. ctl_run_thre=ctl_run_thre,
  278. )
  280. metrics['spine_length'][dname] = Curve_length(ctl_tmp.vertices_center )
  281. metrics['head_length'][dname]=metrics['spine_length'][dname]
  284. head_index=list(set(spine_index).intersection(vertices_head_index_set))
  285. neck_index=list(set(spine_index).intersection(vertices_neck_index_set))
  288. metrics['spine_vol'][dname]=vol=volume(vertices=self.vertices_00[spine_index],faces=spine_faces)
  289. metrics['head_vol'][dname]= vol
  290. mesh=curv_mesh(vertices=self.vertices_00[spine_index],faces=spine_faces)
  291. mesh.Curvature()
  292. metrics['spine_area'][dname]=mesh.areas
  293. metrics['head_area'][dname]=mesh.areas
  296. vertices_index=spine_index
  297. facess=spine_faces
  298. neck_vertices_index=vertices_index_unique
  299. metrics['neck_vol'][dname]=0.
  300. metrics['neck_area'][dname]=0.
  301. metrics['neck_length'][dname]=0.
  302. if node_head is None:
  303. node_head=Branch_division(
  304. cclu=self.cclu,
  305. dend=self.dend,
  306. vertices_index=head_index,
  307. size_threshold= 2,
  308. )
  309. if len(node_head.children)<1:
  310. vertices_index=spine_index
  311. facess=spine_faces
  313. neck_vertices_index=vertices_index_unique
  314. neck_facess=facess
  316. else:
  317. if node_neck is None:
  318. node_neck=Branch_division(
  319. cclu=self.cclu,
  320. dend=self.dend,
  321. vertices_index=neck_index,
  322. size_threshold= 2,
  323. )
  324. if (node_neck.children is not None) and len(node_neck.children)>0:
  325. neck_vertices_index=node_neck.children[0].vertices_index
  326. neck_facess=node_neck.children[0].faces
  327. neck_vertices_index_unique=node_neck.children[0].vertices_index_unique
  328. metrics['neck_vol'][dname]=volume(vertices=self.vertices_00[neck_vertices_index],faces=neck_facess)
  329. mesh=curv_mesh(vertices=self.vertices_00[neck_vertices_index],faces=neck_facess)
  330. mesh.Curvature()
  331. metrics['neck_area'][dname]=mesh.areas
  333. ctl_tmp=get_center_lines(
  334. vertices =self.vertices_00[neck_vertices_index],
  335. vertices_center= vertices_center,
  336. subsample_thre=subsample_thre,
  337. f=f,
  338. N=N,
  339. num_chunks=num_chunks,
  340. num_points=num_points,
  341. line_num_points= line_num_points,
  342. line_num_points_inter= line_num_points_inter,
  343. spline_smooth= spline_smooth,
  344. ctl_run_thre=ctl_run_thre,
  345. )
  348. metrics['neck_length'][dname] = Curve_length(ctl_tmp.vertices_center )
  349. else:
  350. neck_vertices_index= vertices_index_unique
  351. neck_facess=vertices_index_unique
  352. neck_vertices_index_unique= vertices_index_unique
  353. if (node_head.children is not None) and len(node_head.children)>0:
  354. vertices_index=node_head.children[0].vertices_index
  355. facess=node_head.children[0].faces
  356. vertices_index_unique=node_head.children[0].vertices_index_unique
  357. metrics['head_vol'][dname]=volume(vertices=self.vertices_00[vertices_index],faces=facess)
  358. mesh=curv_mesh(vertices=self.vertices_00[vertices_index],faces=facess)
  359. mesh.Curvature()
  360. metrics['head_area'][dname]=mesh.areas
  361. ctl_tmp=get_center_lines(
  362. vertices =self.vertices_00[vertices_index],
  363. vertices_center= vertices_center,
  364. subsample_thre=subsample_thre,
  365. f=f,
  366. N=N,
  367. num_chunks=num_chunks,
  368. num_points=num_points,
  369. line_num_points= line_num_points,
  370. line_num_points_inter= line_num_points_inter,
  371. spline_smooth= spline_smooth,
  372. ctl_run_thre=ctl_run_thre,
  373. )
  376. metrics['head_length'][dname] = Curve_length(ctl_tmp.vertices_center )
  382. class pinn_data(pinn_data_init):
  383. def __init__(self, file_path_feat=None,
  384. dict_mesh_to_skeleton_finder_mesh=None,
  385. **kwargs):
  386. super().__init__(**kwargs)
  387. self.file_path_feat=file_path_feat
  388. self.dict_mesh_to_skeleton_finder_mesh=dict_mesh_to_skeleton_finder_mesh
  391. def get_annotation(self,
  392. dend_first_name=None,
  393. spine_path=None,
  394. shaft_path=None,
  395. file_path=None,
  396. dend_path_original_m=None,
  397. radius_threshold=None,
  398. disp_infos=None,
  399. size_threshold=None,
  400. file_path_feat=None,
  401. dend_path_original_new_smooth=None,
  402. dend_path_org_new=None,
  403. dend_name=None,
  404. ):
  405. disp_infos=disp_infos or self.disp_infos
  406. file_path = file_path or self.file_path
  407. file_path_feat = file_path_feat or self.file_path_feat
  408. spine_path = spine_path or self.spine_path
  409. shaft_path = shaft_path or self.shaft_path
  410. dend_path_original_m=dend_path_original_m or self.dend_path_original_m
  411. radius_threshold = radius_threshold or self.radius_threshold
  412. size_threshold=size_threshold or self.size_threshold
  413. dend_first_name=dend_first_name or self.dend_first_name
  414. if disp_infos:
  415. print(f"Annotation path original: {file_path}")
  416. print(f"Annotation path original dend_path_original_m: {dend_path_original_m}")
  417. from sklearn.neighbors import KDTree
  419. vertices_00 = np.loadtxt(os.path.join(file_path, self.txt_vertices_1), dtype=float)
  420. vertices_0 = np.loadtxt(os.path.join(file_path, self.txt_vertices_0), dtype=float)
  421. faces = np.loadtxt(os.path.join(file_path, self.txt_faces), dtype=int)
  425. os.makedirs( dend_path_org_new, exist_ok=True)
  427. mesh = trimesh.Trimesh(vertices=vertices_0, faces=faces)
  428. dend_nameu=dend_name or 'mesh'
  429. mesh.export(os.path.join(dend_path_original_new_smooth,f'{dend_nameu}.obj'))
  432. mesh = trimesh.Trimesh(vertices=vertices_00, faces=faces)
  433. dend_nameu=dend_name or 'mesh'
  434. mesh.export(os.path.join(dend_path_org_new,f'{dend_nameu}.obj'))
  439. self.mapp=mappings_vertices(vertices_0=vertices_00)
  440. if not os.path.exists(os.path.join(file_path_feat,self.pkl_vertex_neighbor)):
  441. dend = curv_mesh(vertices=vertices_00,
  442. faces=faces, )
  443. dend.Vertices_neighbor()
  445. with open(os.path.join(file_path_feat,self.pkl_vertex_neighbor), "wb") as file:
  446. pickle.dump(dend.vertex_neighbor, file)
  447. else:
  448. with open(os.path.join(file_path_feat,self.pkl_vertex_neighbor), 'rb') as f:
  449. vertex_neighbor = pickle.load(f)#
  450. dend = curv_mesh(vertices=vertices_00,
  451. faces=faces,
  452. vertex_neighbor=vertex_neighbor, )
  453. kdtree_00=KDTree(vertices_00)
  454. shaft=[]
  455. intensity_org=-20*np.ones_like(vertices_00[:,0:1])
  456. cclu=cluster_class(faces_neighbor_index= dend.vertex_neighbor)
  457. obj_indices = get_obj_filenames_with_indices_2(directory=dend_path_original_m,
  458. startwith=f'{dend_first_name}{self.name_spine_id}')
  459. if len(obj_indices)==0:
  460. return
  461. np.savetxt(os.path.join(spine_path,'spine_count_org.txt'),obj_indices, fmt='%s')
  462. vertices_index_appr_all=[]
  463. count=[]
  464. for ip,nam in enumerate(obj_indices):
  465. vertices_sp, _ = Obj_to_vertices(
  466. file_path_original= dend_path_original_m,
  467. mesh_name=nam,
  468. faces_new_mesh=False,
  469. save=False
  470. )
  471. vertices_index_appr=np.array(list(set(np.concatenate(kdtree_00.query_radius(vertices_sp,radius_threshold)))))
  472. print('vertices_index_appr',vertices_sp.shape,len(vertices_index_appr))
  473. if len(vertices_index_appr)> size_threshold:
  474. nodee=Branch_division(
  475. cclu=cclu,
  476. dend=dend,
  477. vertices_index=vertices_index_appr,
  478. size_threshold= size_threshold,
  479. stop_index=1 )
  480. vertices_index_appr_all.extend(nodee.children[0].vertices_index)
  481. if len(nodee.children)>0:
  482. vertices_index=nodee.children[0].vertices_index
  483. faces=nodee.children[0].faces
  484. vertices_index_unique=nodee.children[0].vertices_index_unique
  485. intensity_org[vertices_index ]=ip
  486. np.savetxt(os.path.join(spine_path, f'{self.name_spine_index}_{ip}.txt'), vertices_index, fmt='%d')
  487. np.savetxt(os.path.join(spine_path, f'{self.name_spine_faces}_{ip}.txt'), faces, fmt='%d')
  488. np.savetxt(os.path.join(spine_path, f'{self.name_spine_index_unique}_{ip}.txt'), vertices_index_unique, fmt='%d')
  489. count.append(ip)
  490. mesh=trimesh.Trimesh(vertices=vertices_00[vertices_index],faces=faces)
  491. mesh.export(os.path.join(dend_path_org_new,f'{dend_first_name}{self.name_spine_id}_{ip}.obj') )
  492. mesh=trimesh.Trimesh(vertices=vertices_0[vertices_index],faces=faces)
  493. mesh.export(os.path.join(dend_path_original_new_smooth,f'{dend_first_name}{self.name_spine_id}_{ip}.obj') )
  494. else:
  495. if disp_infos:
  496. print(obj_indices[ip],vertices_index_appr.shape)
  498. np.savetxt(os.path.join(spine_path,'spine_count.txt'),np.array(count), fmt='%d')
  499. vertices_index_shaft=np.array(list(set(np.arange(vertices_00.shape[0]))-set(vertices_index_appr_all)))
  500. np.savetxt(os.path.join(spine_path, self.txt_spine_intensity ), intensity_org, fmt='%d')
  501. if len(vertices_index_shaft)> size_threshold:
  502. nodee=Branch_division(
  503. cclu=cclu,
  504. dend=dend,
  505. vertices_index=vertices_index_shaft,
  506. size_threshold= size_threshold,
  507. stop_index=1 )
  508. if len(nodee.children)>0:
  509. vertices_index=nodee.children[0].vertices_index
  510. faces=nodee.children[0].faces
  511. vertices_index_unique=nodee.children[0].vertices_index_unique
  512. np.savetxt(os.path.join(shaft_path, self.txt_shaft_index), vertices_index, fmt='%d')
  513. np.savetxt(os.path.join(shaft_path, self.txt_shaft_faces), faces, fmt='%d')
  514. np.savetxt(os.path.join(shaft_path, self.txt_shaft_index_unique), vertices_index_unique, fmt='%d')
  516. mesh=trimesh.Trimesh(vertices=vertices_00[vertices_index],faces=faces)
  517. mesh.export(os.path.join(dend_path_org_new,f'{dend_first_name}{self.name_spine_id}_shaft.obj') )
  519. mesh=trimesh.Trimesh(vertices=vertices_0[vertices_index],faces=faces)
  520. mesh.export(os.path.join(dend_path_original_new_smooth,f'{dend_first_name}{self.name_spine_id}_shaft.obj') )
  525. def get_intensity_rhs(self,
  526. dend_first_name=None,
  527. spine_path=None,
  528. shaft_path=None,
  529. file_path=None,
  530. dend_path_original_m=None,
  531. radius_threshold=None,
  532. disp_infos=None,
  533. size_threshold=None,
  534. file_path_feat=None,
  535. ):
  536. disp_infos=disp_infos or self.disp_infos
  537. file_path = file_path or self.file_path
  538. file_path_feat=file_path_feat or self.file_path_feat
  539. spine_path = spine_path or self.spine_path
  540. shaft_path = shaft_path or self.shaft_path
  541. dend_path_original_m=dend_path_original_m or self.dend_path_original_m
  542. radius_threshold = radius_threshold or self.radius_threshold
  543. size_threshold=size_threshold or self.size_threshold
  544. dend_first_name=dend_first_name or self.dend_first_name
  545. if disp_infos:
  546. print(f"get_intensity_head_neck: {file_path}")
  548. vertices_00 = np.loadtxt(os.path.join(file_path, self.txt_vertices_1), dtype=float)
  550. intensity = np.zeros(vertices_00.shape[0])
  551. intensity_1hot=np.zeros_like(vertices_00[:,:-1],dtype=int)
  552. count= hff.loadtxt_count(os.path.join(spine_path,self.txt_spine_count))
  553. mmm=count.ndim
  554. spine_index_all=[]
  555. count=count if mmm==2 else count.reshape(-1,1)
  556. for i in range(count.shape[0]):
  557. ii=count[i,0]
  558. if ii <0:
  559. continue
  560. name=f'{ii}_{count[i,1]}' if mmm==2 else f'{count[i,0]}'
  561. spine_index = np.loadtxt(os.path.join(spine_path, f'{self.name_spine_index}_{name}.txt'),dtype=int)
  562. intensity[spine_index]=1
  563. spine_index_all.extend(spine_index)
  564. intensity_1hot[:,1:2][spine_index_all]=1
  565. intensity_1hot[:,0:1][list(set(np.arange(vertices_00.shape[0]))-set(spine_index_all))]=1
  566. np.savetxt(os.path.join(self.file_path_feat,'intensity_shaft_spine.txt'), intensity, fmt='%d')
  567. np.savetxt(os.path.join(self.file_path_feat,'intensity_1hot_shaft_spine.txt'), intensity_1hot, fmt='%d')
  572. def get_annotation_resized(self,
  573. file_path_resized,
  574. shaft_path_resized,
  575. dend_path_org_resized,
  576. dend_path_org_smooth_resized,
  577. dend_first_name=None,
  578. spine_path=None,
  579. shaft_path=None,
  580. file_path=None,
  581. file_path_feat=None,
  582. dend_path_original_m=None,
  583. radius_threshold=None,
  584. disp_infos=None,
  585. size_threshold=None,
  586. train_tf=None,
  587. thre_target_number_of_triangles=40000,
  588. min_target_number_of_triangles_faction=600000,
  589. target_number_of_triangles_faction=1000,
  590. voxel_resolution=2064,
  591. dict_mesh_to_skeleton_finder_mesh=None,
  592. dend_name=None,
  593. ):
  594. dict_mesh_to_skeleton_finder_mesh=dict_mesh_to_skeleton_finder_mesh or self.dict_mesh_to_skeleton_finder_mesh
  595. disp_infos=disp_infos or self.disp_infos
  596. file_path = file_path or self.file_path
  597. file_path_feat = file_path_feat or self.file_path_feat
  598. spine_path = spine_path or self.spine_path
  599. shaft_path = shaft_path or self.shaft_path
  600. dend_path_original_m=dend_path_original_m or self.dend_path_original_m
  601. radius_threshold = radius_threshold or self.radius_threshold
  602. size_threshold=size_threshold or self.size_threshold
  603. dend_first_name=dend_first_name or self.dend_first_name
  604. os.makedirs(file_path_resized, exist_ok=True)
  605. os.makedirs(shaft_path_resized, exist_ok=True)
  606. os.makedirs(os.path.join(file_path_resized,'feat'), exist_ok=True)
  607. os.makedirs( dend_path_org_resized, exist_ok=True)
  608. os.makedirs( dend_path_org_smooth_resized, exist_ok=True)
  609. if disp_infos:
  610. print(f"Annotation path original: {file_path}")
  611. print(f"================================= get_annotation_resized ====================================")
  616. vertices_00 = np.loadtxt(os.path.join(file_path, self.txt_vertices_1), dtype=float)
  617. n_vert=vertices_00.shape[0]
  618. vertices_0 = np.loadtxt(os.path.join(file_path, self.txt_vertices_0), dtype=float)
  619. faces = np.loadtxt(os.path.join(file_path, self.txt_faces), dtype=int)
  620. # target_number_of_triangles_faction=max(vertices_0.shape[0]//dict_mesh_to_skeleton_finder_mesh['target_number_of_triangles_faction'],
  621. # dict_mesh_to_skeleton_finder_mesh['min_target_number_of_triangles_faction'],)
  622. target_number_of_triangles_faction=max(vertices_0.shape[0]// target_number_of_triangles_faction, 2*min_target_number_of_triangles_faction)
  623. self.skl=skl=mesh_resize(vertices=vertices_00,
  624. faces=faces,
  625. target_number_of_triangles=target_number_of_triangles_faction ,)
  627. vertices_00 = skl.mesh.vertices
  628. vertices_0 = skl.reduce_rhs(vertices_0)
  629. faces = skl.mesh.faces
  631. mesh = trimesh.Trimesh(vertices=vertices_00, faces=faces)
  632. dend_nameu=dend_name or 'mesh'
  633. mesh.export(os.path.join(dend_path_org_resized,f'{dend_nameu}.obj'))
  635. np.savetxt(os.path.join(file_path_resized, self.txt_vertices_1), skl.mesh.vertices, fmt='%f')
  636. np.savetxt(os.path.join(file_path_resized, self.txt_faces), skl.mesh.faces, fmt='%d')
  637. np.savetxt(os.path.join(file_path_resized, self.txt_vertices_0), vertices_0 , fmt='%f')
  639. mesh=trimesh.Trimesh(vertices=vertices_0,faces=faces)
  640. mesh.export(os.path.join(dend_path_org_smooth_resized,f'{dend_name}.obj') )
  642. if os.path.exists(os.path.join(spine_path,'spine_count_org.txt')):
  643. if not os.path.exists(os.path.join(file_path_resized,self.pkl_vertex_neighbor)):
  644. dend = curv_mesh(vertices=vertices_00,
  645. faces=faces, )
  646. dend.Vertices_neighbor()
  647. vertex_neighbor=dend.vertex_neighbor
  649. with open(os.path.join(file_path_resized,self.pkl_vertex_neighbor), "wb") as file:
  650. pickle.dump(dend.vertex_neighbor, file)
  651. else:
  652. with open(os.path.join(file_path_resized,self.pkl_vertex_neighbor), 'rb') as f:
  653. vertex_neighbor = pickle.load(f)#
  654. dend = curv_mesh(vertices=vertices_00,
  655. faces=faces,
  656. vertex_neighbor=vertex_neighbor, )
  657. cclu=cluster_class(faces_neighbor_index= vertex_neighbor)
  658. shaft=[]
  659. intensity_org=-20*np.ones_like(vertices_00[:,0:1])
  660. obj_indices=np.loadtxt(os.path.join(spine_path,'spine_count_org.txt'),dtype=str,ndmin=1)
  661. np.savetxt(os.path.join(shaft_path_resized,'spine_count_org.txt'), obj_indices, fmt='%s')
  662. vertices_index_appr_all=[]
  663. count=[]
  664. for ip,nam in enumerate(obj_indices):
  665. if nam.endswith('shaft'):
  666. continue
  667. intensity_sp= np.zeros(n_vert)
  668. vertices_index=np.loadtxt(os.path.join(spine_path, f'{self.name_spine_index}_{ip}.txt'), dtype=int)
  669. intensity_sp[vertices_index]=1
  670. vertices_index= skl.reduce_rhs( intensity_sp).astype(int)
  671. vertices_index=np.where(vertices_index==1)[0]
  674. cclu.Cluster_index(ln_elm= vertices_index)
  675. cclu.Cluster_faces()
  676. cclu.Cluster_faces_unique()
  677. if len(cclu.cluster_index)>0:
  678. intensity_org[cclu.cluster_index ]=ip
  679. np.savetxt(os.path.join(shaft_path_resized, f'{self.name_spine_index}_{ip}.txt'), cclu.cluster_index, fmt='%d')
  680. np.savetxt(os.path.join(shaft_path_resized, f'{self.name_spine_faces}_{ip}.txt'), cclu.cluster_faces, fmt='%d')
  681. np.savetxt(os.path.join(shaft_path_resized, f'{self.name_spine_index_unique}_{ip}.txt'), cclu.cluster_faces_unique, fmt='%d')
  683. mesh=trimesh.Trimesh(vertices=vertices_00[cclu.cluster_index],faces=cclu.cluster_faces)
  684. mesh.export(os.path.join(dend_path_org_resized,f'{dend_first_name}{self.name_spine_id}_{ip}.obj') )
  685. mesh=trimesh.Trimesh(vertices=vertices_0[cclu.cluster_index],faces=cclu.cluster_faces)
  686. mesh.export(os.path.join(dend_path_org_smooth_resized,f'{dend_first_name}{self.name_spine_id}_{ip}.obj') )
  689. count.append(ip)
  690. vertices_index_appr_all.extend(cclu.cluster_index)
  693. np.savetxt(os.path.join(shaft_path_resized,'spine_count.txt'),np.array(count), fmt='%d')
  694. sett=set(np.arange(vertices_0.shape[0]))
  695. vertices_index_shaft=list(sett-set(vertices_index_appr_all).intersection(sett))
  696. np.savetxt(os.path.join(shaft_path_resized, self.txt_spine_intensity ), intensity_org, fmt='%d')
  698. if len(vertices_index_shaft)> size_threshold:
  699. cclu.Cluster_index(ln_elm= vertices_index_shaft)
  700. cclu.Cluster_faces()
  701. cclu.Cluster_faces_unique()
  702. np.savetxt(os.path.join(shaft_path_resized, self.txt_shaft_index), cclu.cluster_index, fmt='%d')
  703. np.savetxt(os.path.join(shaft_path_resized, self.txt_shaft_faces), cclu.cluster_faces, fmt='%d')
  704. np.savetxt(os.path.join(shaft_path_resized, self.txt_shaft_index_unique), cclu.cluster_faces_unique, fmt='%d')
  706. mesh=trimesh.Trimesh(vertices=vertices_00[cclu.cluster_index],faces=cclu.cluster_faces)
  707. mesh.export(os.path.join(dend_path_org_resized,f'{dend_first_name}_shaft.obj') )
  708. mesh=trimesh.Trimesh(vertices=vertices_0[cclu.cluster_index],faces=cclu.cluster_faces)
  709. mesh.export(os.path.join(dend_path_org_smooth_resized,f'{dend_first_name}_shaft.obj') )
  712. def get_pinn_features(self,
  713. feat_paths= None,
  714. base_features_list=None,
  715. file_path=None,
  716. file_path_feat=None,
  717. thre_gauss=None,
  718. thre_mean=None,
  719. head_neck=False,
  720. shaft_path_init=None,
  721. spine_path_init=None,
  722. ):
  723. add_feats=[]
  724. for vcv in feat_paths:
  725. if os.path.exists(vcv):
  726. add_feat=np.loadtxt(vcv)
  727. else:
  728. add_feat=None
  729. add_feats.append(add_feat)
  730. file_path = file_path or self.file_path
  731. file_path_feat = file_path_feat or self.file_path_feat
  732. thre_gauss=thre_gauss or self.thre_gauss
  733. thre_mean=thre_mean or self.thre_mean
  736. self.mean_curv= np.loadtxt(os.path.join(file_path_feat, self.txt_mean_curv_smooth), dtype=float)
  737. self.gauss_curv= np.loadtxt(os.path.join(file_path_feat, self.txt_gauss_curv_smooth), dtype=float)
  738. self.skl_curv= np.loadtxt(os.path.join(file_path_feat, self.txt_skl_distance), dtype=float)
  739. # self.skl_curv_con= np.loadtxt(os.path.join(file_path_feat, self.txt_skl_distance_con), dtype=float)
  740. # self.skl_curv_imp_con = Impute_intensity(self.skl_curv_con)
  741. self.skl_curv_imp =skl_curv_imp= Impute_intensity(self.skl_curv)
  742. self.mean_curv_imp=mean_curv_imp=Threshold_curv(curv=Impute_intensity(self.mean_curv) , thre=thre_mean)
  743. self.gauss_curv_imp=gauss_curv_imp=Threshold_curv(curv=Impute_intensity(self.gauss_curv) ,thre=thre_gauss)
  746. self.mean_sq_curv =np.loadtxt(os.path.join(file_path_feat, self.txt_mean_sq_curv_smooth), dtype=float)
  747. self.gauss_sq_curv =np.loadtxt(os.path.join(file_path_feat, self.txt_gauss_sq_curv_smooth), dtype=float)
  748. self.mean_sq_curv_imp=Threshold_curv(curv=Impute_intensity(self.mean_sq_curv), thre=thre_mean)
  749. self.gauss_sq_curv_imp=Threshold_curv(curv=Impute_intensity(self.gauss_sq_curv),thre=thre_gauss)
  751. self.skl_curv_org= np.loadtxt(os.path.join(file_path_feat, 'skl_distance_org.txt'), dtype=float)
  752. self.skl_curv_imp_org = Impute_intensity(self.skl_curv_org)
  755. self.mean_curv_init =np.loadtxt(os.path.join(file_path_feat, self.txt_mean_curv_init), dtype=float)
  756. self.gauss_curv_init=np.loadtxt(os.path.join(file_path_feat, self.txt_gauss_curv_init), dtype=float)
  757. self.mean_curv_init_imp=Threshold_curv(curv=Impute_intensity(self.mean_curv_init) , thre=thre_mean)
  758. self.gauss_curv_init_imp=Threshold_curv(curv=Impute_intensity(self.gauss_curv_init) , thre=thre_mean)
  760. mean_sq_curv_init =np.loadtxt(os.path.join(file_path_feat, self.txt_mean_sq_curv_init), dtype=float)
  761. gauss_sq_curv_init =np.loadtxt(os.path.join(file_path_feat, self.txt_gauss_sq_curv_init), dtype=float)
  762. self.mean_sq_curv_init_imp=Threshold_curv(curv=Impute_intensity(mean_sq_curv_init), thre=thre_mean)
  763. self.gauss_sq_curv_init_imp=Threshold_curv(curv=Impute_intensity(gauss_sq_curv_init),thre=thre_gauss)
  765. curv_k=mean_curv_imp+np.abs(mean_curv_imp**2-gauss_curv_imp)**(1/2)
  766. curv_v=mean_curv_imp-np.abs(mean_curv_imp**2-gauss_curv_imp)**(1/2)
  768. self.base_features_dict['curv_k']['values']=curv_k
  769. self.base_features_dict['curv_v']['values']=curv_v
  770. self.base_features_dict['curv_k2']['values']=curv_k**2
  771. self.base_features_dict['curv_v2']['values']=curv_v**2
  772. self.base_features_dict['curv_kv']['values']=curv_v*curv_k
  773. self.base_features_dict['curv_kv22']['values']=(curv_v*curv_k)**2
  777. self.base_features_dict['gauss']['values']=gauss_curv_imp
  778. self.base_features_dict['mean']['values']=mean_curv_imp
  779. self.base_features_dict['gauss_sq']['values']=self.gauss_sq_curv_imp #gauss_curv_imp**2#
  780. self.base_features_dict['mean_sq']['values']=self.mean_sq_curv_imp #mean_curv_imp**2#
  781. self.base_features_dict['gauss_qd']['values']=gauss_curv_imp**4
  782. self.base_features_dict['mean_qd']['values']=mean_curv_imp**4
  784. self.base_features_dict['igauss']['values']=self.gauss_curv_init_imp
  785. self.base_features_dict['imean']['values']=self.mean_curv_init_imp
  786. self.base_features_dict['igauss_sq']['values']=self.gauss_sq_curv_init_imp
  787. self.base_features_dict['imean_sq']['values']=self.mean_sq_curv_init_imp
  789. self.base_features_dict['skl']['values']=hff.normalize( (skl_curv_imp))
  790. for rf in self.kmean_list:
  791. self.base_features_dict[f'kmean_{rf}']['values']= get_kmean(skl_curv_imp,n_clusters=rf,kmean_max_iter=600).reshape(-1,1)
  792. for rf in self.kmean_list:
  793. self.base_features_dict[f'kmean_mean_{rf}']['values']= get_kmean(self.skl_curv_imp_org,n_clusters=rf,kmean_max_iter=600).reshape(-1,1)
  795. if base_features_list is not None:
  796. base_featuress=base_features_list
  797. else:
  798. base_featuress=self.base_features_dict.keys()
  799. base_features=[]
  800. for ii in base_featuress:
  801. ngn=self.base_features_dict[ii]['values']
  802. base_features.append(ngn)
  803. patr=os.path.join(self.file_path_feat,f'{ii}.txt')
  805. for ii in self.base_features_dict.keys():
  806. ngn=self.base_features_dict[ii]['values']
  807. patr=os.path.join(self.file_path_feat,f'{ii}.txt')
  808. np.savetxt(patr,ngn,fmt='%f')
  811. for add_feat in add_feats:
  812. if add_feat is not None:
  813. base_features= get_model(base_features= base_features,
  814. vcv_length=add_feat,
  815. model_sufix=self.model_sufix)
  816. else:
  817. print(f'I activated {self.model_sufix}')
  818. return base_features
  821. def get_central_data(
  822. self,
  823. line_num_points_shaft=None,
  824. line_num_points_inter_shaft=None,
  825. spline_smooth_shaft=None,
  826. shaft_path=None,
  827. ctl_run_thre=1,
  828. smooth_tf=False,
  829. vertices_center=None,
  830. ):
  831. dend=self.dend
  832. shaft_path=shaft_path or self.shaft_path_pre or self.shaft_path
  833. line_num_points_shaft=line_num_points_shaft or self.line_num_points_shaft
  834. line_num_points_inter_shaft=line_num_points_inter_shaft or self.line_num_points_inter_shaft
  835. spline_smooth_shaft=spline_smooth_shaft or self.spline_smooth_shaft
  837. # vertices_index_shaft=shaft_index=spn.children[0].vertices_index
  838. print('shaft_path----------->>>>>>. get_central_data----------->>>>>>.',shaft_path)
  839. # print('spline_smooth_shaft',spline_smooth_shaft)
  840. vertices_0=dend.vertices
  841. vcv_length_path=os.path.join( shaft_path, self.txt_shaft_vcv_length)
  842. vertices_center_path=os.path.join( shaft_path, self.txt_shaft_vertices_center)
  843. # print('vcv destination----------->>>>>>.',vcv_length_path)
  844. # if not (os.path.exists(vertices_center_path) and os.path.exists(vcv_length_path)):
  845. vertices_00 = np.loadtxt(os.path.join(self.file_path, self.txt_vertices_1), dtype=float)
  846. self.mapp=mappings_vertices(vertices_0=dend.vertices)
  847. self.kdtree=KDTree(vertices_0)
  848. self.cclu=cluster_class(faces_neighbor_index=dend.vertex_neighbor)
  849. if os.path.exists(os.path.join(shaft_path, self.txt_shaft_index)):
  850. shaft_index = np.loadtxt(os.path.join(shaft_path, self.txt_shaft_index), dtype=int)
  851. # faces = np.loadtxt(os.path.join(shaft_path, self.txt_faces), dtype=int)
  853. # if not os.path.exists(vertices_center_path):
  854. # return
  855. line_num_points_shaft = max(vertices_00.shape[0] // line_num_points_shaft, 10)
  856. print('line_num_points_shaft----------->>>>>>.[[]]',line_num_points_shaft,line_num_points_inter_shaft,spline_smooth_shaft)
  857. if vertices_center is not None:
  858. # if not (os.path.exists(vcv_length_path) and os.path.exists(vertices_center_path)):
  859. ctl = center_curvature(vertices=vertices_center,
  860. line_num_points=line_num_points_shaft,
  861. line_num_points_inter=line_num_points_inter_shaft,
  862. spline_smooth=spline_smooth_shaft,
  863. smooth_tf=smooth_tf,)
  864. np.savetxt(vcv_length_path, ctl.vcv_length, fmt='%f')
  865. self.vcv_length= np.loadtxt(vcv_length_path,ndmin=1)
  866. np.savetxt(vertices_center_path, ctl.vertices_center, fmt='%f')
  867. print('=========== im in',vcv_length_path)
  868. # else:
  870. # ctl = center_curvature(vertices=vertices_00,
  871. # vertices_index=shaft_index,
  872. # line_num_points=line_num_points_shaft,
  873. # line_num_points_inter=line_num_points_inter_shaft,
  874. # spline_smooth=spline_smooth_shaft,
  875. # smooth_tf=smooth_tf,)
  877. self.shaft_index=shaft_index=np.loadtxt(os.path.join( shaft_path, self.txt_shaft_index),dtype=int)
  878. self.vertices_center = np.loadtxt(vertices_center_path)
  879. self.vcv_length= np.loadtxt(vcv_length_path,ndmin=1)
  880. self.clu_pca=clust_pca(vertices_0,shaft_index,
  881. vertices_center= self.vertices_center,
  882. vcv_length=self.vcv_length)
  884. print('shaft_path----------->>>>>>. get_central_data----------->>>>>>.DONE' )
  886. def save_pinn_data(self,
  887. file_path=None,
  888. file_path_feat=None,
  889. spine_path=None,
  890. shaft_path=None,
  891. thre_gen=None,
  892. thre_target_number_of_triangles=None,
  893. voxel_resolution =None,
  894. dict_mesh_to_skeleton_finder_mesh=None,
  895. ):
  896. file_path = file_path or self.file_path
  897. file_path_feat = file_path_feat or self.file_path_feat
  898. shaft_path=shaft_path or self.shaft_path
  899. spine_path=spine_path or self.spine_path
  900. thre_gen=thre_gen or self.thre_gen
  901. thre_target_number_of_triangles=thre_target_number_of_triangles or self.thre_target_number_of_triangles
  902. dict_mesh_to_skeleton_finder_mesh=dict_mesh_to_skeleton_finder_mesh or self.dict_mesh_to_skeleton_finder_mesh
  904. print('self.file_path',self.file_path)
  905. voxel_resolution=voxel_resolution or self.voxel_resolution
  906. self.vertices_00 =vertices_00 = np.loadtxt(os.path.join(file_path, self.txt_vertices_1), dtype=float)
  907. faces = np.loadtxt(os.path.join(file_path, self.txt_faces), dtype=int)
  908. dend = curv_mesh(vertices=vertices_00, faces=faces)
  910. dend.Gauss_curv()
  911. dend.Mean_curv()
  913. gauss_curv=Threshold_curv(curv=dend.gauss_curv,thre=thre_gen)
  914. mean_curv=Threshold_curv(curv=dend.mean_curv,thre=thre_gen)
  915. gauss_sq_curv=Threshold_curv(curv=dend.gauss_curv*dend.gauss_curv,thre=thre_gen)
  916. mean_sq_curv=Threshold_curv(curv=dend.mean_curv*dend.mean_curv,thre=thre_gen)
  917. np.savetxt(os.path.join(file_path_feat, self.txt_gauss_curv_init),gauss_curv, fmt='%f')
  918. np.savetxt(os.path.join(file_path_feat, self.txt_mean_curv_init),mean_curv, fmt='%f')
  919. gauss_sq_curv=Threshold_curv(curv=dend.gauss_curv*dend.gauss_curv,thre=thre_gen)
  920. mean_sq_curv=Threshold_curv(curv=dend.mean_curv*dend.mean_curv,thre=thre_gen)
  921. np.savetxt(os.path.join(file_path_feat, self.txt_gauss_sq_curv_init),gauss_sq_curv, fmt='%f')
  922. np.savetxt(os.path.join(file_path_feat, self.txt_mean_sq_curv_init),mean_sq_curv, fmt='%f')
  923. # np.savetxt(os.path.join(file_path, self.txt_faces_class_faces), faces_class_faces, fmt='%d')
  924. # np.savetxt(os.path.join(file_path, self.txt_vertex_neighbor),vertex_neighbor, fmt='%d')
  926. vertices_0 = np.loadtxt(os.path.join(file_path, self.txt_vertices_0), dtype=float)
  927. # vertices_0 -= np.mean(vertices_0, axis=0)
  928. dend = curv_mesh(vertices=vertices_0, faces=faces )
  929. if not os.path.exists(os.path.join(file_path_feat,self.pkl_vertex_neighbor)):
  930. dend.Vertices_neighbor()
  931. with open(os.path.join(file_path_feat,self.pkl_vertex_neighbor), "wb") as file:
  932. pickle.dump(dend.vertex_neighbor, file)
  933. else:
  934. with open(os.path.join(file_path_feat,self.pkl_vertex_neighbor) , "rb") as file:
  935. dend.vertex_neighbor=pickle.load(file)
  936. # if not os.path.exists(os.path.join(file_path, self.txt_gauss_curv_smooth)):
  937. # if os.path.exists(os.path.join(file_path, self.txt_vertices_0)):
  938. dend.Gauss_curv()
  939. dend.Mean_curv()
  940. self.dend=dend
  941. gauss_curv=Threshold_curv(curv=dend.gauss_curv,thre=thre_gen)
  942. mean_curv=Threshold_curv(curv=dend.mean_curv,thre=thre_gen)
  943. np.savetxt(os.path.join(file_path_feat, self.txt_gauss_curv_smooth),gauss_curv, fmt='%f')
  944. np.savetxt(os.path.join(file_path_feat, self.txt_mean_curv_smooth),mean_curv, fmt='%f')
  945. gauss_sq_curv=Threshold_curv(curv=dend.gauss_curv*dend.gauss_curv,thre=thre_gen)
  946. mean_sq_curv=Threshold_curv(curv=dend.mean_curv*dend.mean_curv,thre=thre_gen)
  947. np.savetxt(os.path.join(file_path_feat, self.txt_gauss_sq_curv_smooth),gauss_sq_curv, fmt='%f')
  948. np.savetxt(os.path.join(file_path_feat, self.txt_mean_sq_curv_smooth),mean_sq_curv, fmt='%f')
  949. if not os.path.exists(os.path.join(file_path_feat, self.txt_skl_distance)):
  950. self.skl=skl=def_mesh_to_skeleton_finder(vertices=vertices_0,
  951. faces=faces,
  952. ** dict_mesh_to_skeleton_finder_mesh,
  953. )
  954. #
  955. np.savetxt(os.path.join(file_path_feat, self.txt_skl_vectices),skl.skeleton_points, fmt='%f')
  956. np.savetxt(os.path.join(file_path_feat, self.txt_skl_distance),skl.distances, fmt='%f')
  957. np.savetxt(os.path.join(file_path_feat, self.txt_skl_index),skl.skl_index, fmt='%d')
  959. if not os.path.exists(os.path.join(file_path_feat, self.txt_skl_distance_org)):
  960. vertices_00 = np.loadtxt(os.path.join(file_path, self.txt_vertices_1), dtype=float)
  961. skl=def_mesh_to_skeleton_finder(vertices=vertices_00,
  962. faces=faces,
  963. ** dict_mesh_to_skeleton_finder_mesh,
  964. )
  965. np.savetxt(os.path.join(file_path_feat, self.txt_skl_vectices_org),skl.skeleton_points, fmt='%f')
  966. np.savetxt(os.path.join(file_path_feat, self.txt_skl_distance_org),skl.distances, fmt='%f')
  967. np.savetxt(os.path.join(file_path_feat, self.txt_skl_index_org),skl.skl_index, fmt='%d')
  971. def get_shaft_pred(self,
  972. rhs,
  973. path_train,
  974. pre_portion=None,
  975. weight=None,
  976. weights=None,
  977. seg_dend='full',
  978. zoom_thre=25,
  979. skip_first_n=1,
  980. skip_mid_n=None,
  981. skip_end_n=10,
  982. subdivision_thre=3,
  983. subsample_thre=.02,
  984. f=0.99,
  985. N=10,
  986. num_chunks=100,
  987. line_num_points=None,
  988. line_num_points_inter=None,
  989. spline_smooth=None,
  990. num_points=50,
  991. ctl_run_thre=0,
  992. size_threshold=None ,
  993. end_thre=40,
  994. get_refine_=False,
  995. dest_path='dest_spine_path',
  996. spine_fraction=3,
  997. shaft_thre=1/4,
  998. gauss_threshold=10,
  999. smooth_tf=False,
  1000. neck_lim=0,
  1001. get_data_txt=True,
  1002. reconstruction_tf=False,
  1003. dict_mesh_to_skeleton_finder=None,
  1004. dict_wrap=None,
  1005. file_path_feat=None,
  1006. tf_skl_shaft_distance=False,
  1007. ):
  1008. file_path_feat = file_path_feat or self.file_path_feat
  1009. line_num_points=line_num_points or self.line_num_points_shaft
  1010. line_num_points_inter=line_num_points_inter or self.line_num_points_inter_shaft
  1011. spline_smooth=spline_smooth or self.spline_smooth_shaft
  1012. data_shaft_path=self.path_file[path_train['data_spine_path']]
  1013. dest_shaft_path=self.path_file[path_train['dest_shaft_path']]
  1014. shaft_path = self.path_file[path_train['dest_shaft_path']]
  1015. spine_path_new=self.path_file[path_train['dest_spine_path']]
  1016. spine_path = self.path_file[path_train['dest_spine_path']]
  1017. spine_path_new_pre=self.path_file[path_train['dest_spine_path_pre']]
  1018. shaft_vertices_center_path=self.path_file[self.path_train['data_shaft_path']]
  1019. shaft_vertices_center_path_dest=self.path_file[path_train['dest_spine_path_center']]
  1020. dest_spine_path_new=self.path_file[path_train[dest_path]]
  1021. pre_save_txt= False if dest_path=='dest_spine_path_pre' else True
  1022. size_threshold=size_threshold or self.size_threshold
  1025. skl_vertices=np.loadtxt(os.path.join(self.file_path_feat, self.txt_skl_vectices),dtype=float)
  1026. skl_index=np.loadtxt(os.path.join(self.file_path_feat, self.txt_skl_index),dtype=int)
  1027. inten=-1*np.ones_like(rhs[:,0])
  1028. if weight is None:
  1029. siz=rhs.shape[1]
  1030. weight=1/siz*np.ones(siz)
  1031. dend=self.dend
  1032. rhs0=np.array([weight,0.81])*rhs.copy()
  1033. msh_tmp=model_shaft(dend,rhs0, stop_index=1,size_threshold=size_threshold,shaft_thre=shaft_thre,uniq_rem_lim=neck_lim)
  1034. msh_tmp.get_spine_node()
  1035. masa_tmp=len(msh_tmp.node_spine.children)
  1036. msh=msh_tmp
  1037. print(f'get_shaft_pred: -- Weight {weight}| Spine Total Number = {masa_tmp}| size_threshold = {size_threshold}')
  1038. self.msh=msh
  1039. shaft_index=msh.shaft_index
  1040. shaft_faces=msh.shaft_faces
  1041. shaft_index_unique=msh.shaft_index_unique
  1044. if get_data_txt:
  1045. predicted_labels=msh.rhs_vals
  1046. for label in range(rhs.shape[1]):
  1047. self.vertices_approx_index=vertices_approx_index = np.where(predicted_labels == label)[0]
  1048. inten[vertices_approx_index]=label
  1050. cluster = np.ones(dend.n_vert )
  1051. cluster[msh.shaft_index]=0
  1052. intensity_spines_cluster=msh.rhs_vals
  1056. dest_spine_path_pre_init=self.path_file[path_train['dest_spine_path_pre_init']]
  1057. np.savetxt(os.path.join(spine_path,f'intensity_{pre_portion}_segm.txt'), inten, fmt='%d')
  1058. np.savetxt(os.path.join(shaft_path,f'intensity_{pre_portion}_segm.txt'), inten, fmt='%d')
  1059. np.savetxt(os.path.join( dest_spine_path_pre_init,f'intensity_{pre_portion}_segm.txt'),inten, fmt='%d')
  1063. np.savetxt(os.path.join(spine_path, 'intensity_spines_segment_shaft.txt'), cluster, fmt='%d')
  1064. np.savetxt(os.path.join(shaft_path, 'intensity_spines_segment_shaft.txt'), cluster, fmt='%d')
  1067. np.savetxt(os.path.join(spine_path, self.txt_shaft_index), shaft_index, fmt='%d')
  1068. np.savetxt(os.path.join(spine_path, self.txt_shaft_faces), shaft_faces, fmt='%d')
  1069. np.savetxt(os.path.join(spine_path, self.txt_shaft_index_unique), shaft_index_unique, fmt='%d')
  1071. np.savetxt(os.path.join(shaft_path, self.txt_shaft_index), shaft_index, fmt='%d')
  1072. np.savetxt(os.path.join(shaft_path, self.txt_shaft_faces), shaft_faces, fmt='%d')
  1073. np.savetxt(os.path.join(shaft_path, self.txt_shaft_index_unique), shaft_index_unique, fmt='%d')
  1074. skl_vertices=np.loadtxt(os.path.join(self.file_path_feat, self.txt_skl_vectices),dtype=float)
  1075. skl_index=np.loadtxt(os.path.join(self.file_path_feat, self.txt_skl_index),dtype=int)
  1077. self.get_central_data(shaft_path=shaft_path,
  1078. smooth_tf=smooth_tf,
  1079. vertices_center=skl_vertices[skl_index[shaft_index]])
  1080. nodevv=msh.node_spine
  1081. node_io=dendrite_io(txt_save_file=spine_path,
  1082. shaft_index=shaft_index,
  1083. name=self,
  1084. itera_start=0,
  1085. vertices_index=np.arange(self.dend.n_vert,dtype=int),
  1086. faces=self.dend.faces,
  1087. skl_vertices=skl_vertices,
  1088. skl_index=skl_index,
  1089. size_threshold=size_threshold,)
  1090. node_io.node_to_txt(node=nodevv, intensity_len=dend.n_vert, part=self.name_spine)
  1092. node_io=dendrite_io(txt_save_file=shaft_path,
  1093. shaft_index=shaft_index ,
  1094. name=self,
  1095. itera_start=0,
  1096. vertices_index=np.arange(self.dend.n_vert,dtype=int),
  1097. faces=self.dend.faces,
  1098. skl_vertices=skl_vertices,
  1099. skl_index=skl_index,
  1100. size_threshold=size_threshold,)
  1101. node_io.node_to_txt(node=nodevv, intensity_len=dend.n_vert, part=self.name_spine)
  1104. np.savetxt(os.path.join(shaft_path, self.txt_intensity_spines_segment), intensity_spines_cluster, fmt='%d')
  1105. np.savetxt(os.path.join(shaft_vertices_center_path, self.txt_shaft_vertices_center), self.vertices_center, fmt='%f')
  1106. np.savetxt(os.path.join(shaft_vertices_center_path, self.txt_shaft_index), shaft_index, fmt='%d')
  1107. np.savetxt(os.path.join(shaft_vertices_center_path, self.txt_shaft_faces), shaft_faces, fmt='%d')
  1108. np.savetxt(os.path.join(shaft_vertices_center_path, self.txt_shaft_index), shaft_index, fmt='%d')
  1109. np.savetxt(os.path.join(shaft_vertices_center_path, self.txt_shaft_faces), shaft_faces, fmt='%d')
  1110. np.savetxt(os.path.join(shaft_vertices_center_path_dest, self.txt_shaft_vertices_center), self.vertices_center, fmt='%f')
  1112. np.savetxt(os.path.join(shaft_vertices_center_path_dest, self.txt_shaft_vcv_length), self.vcv_length, fmt='%f')
  1113. np.savetxt(os.path.join(shaft_path, self.txt_shaft_vcv_length), self.vcv_length, fmt='%f')
  1114. np.savetxt(os.path.join(shaft_path , self.txt_shaft_vertices_center), self.vertices_center, fmt='%f')
  1115. np.savetxt(os.path.join(file_path_feat, self.txt_shaft_vcv_length), self.vcv_length, fmt='%f')
  1116. np.savetxt(os.path.join(file_path_feat , self.txt_shaft_vertices_center), self.vertices_center, fmt='%f')
  1117. np.savetxt(os.path.join(spine_path_new , 'shaft_vcv_length.txt'), self.vcv_length, fmt='%f')
  1119. if tf_skl_shaft_distance and (dict_mesh_to_skeleton_finder is not None):
  1120. if not os.path.exists(os.path.join(file_path_feat, self.txt_skl_shaft_vectices)):
  1121. vertices_00 = np.loadtxt(os.path.join(self.file_path, self.txt_vertices_1), dtype=float)
  1122. vertices_0 = np.loadtxt(os.path.join(self.file_path, self.txt_vertices_0), dtype=float)
  1123. simplified_vertices,simplified_faces=get_wrap(vertices=vertices_0[shaft_index],
  1124. faces=shaft_faces,
  1125. **dict_wrap,
  1126. )
  1127. mesh = trimesh.Trimesh(vertices=simplified_vertices, faces=simplified_faces)
  1128. mesh.export(os.path.join(file_path_feat,'mesh_wrap.obj'))
  1130. nskl=def_mesh_to_skeleton_finder(vertices=simplified_vertices,
  1131. faces=simplified_faces,
  1132. ** dict_mesh_to_skeleton_finder,
  1133. )
  1136. skeleton_p,_,_=order_points_along_pca(nskl.skeleton_points)
  1137. np.savetxt(os.path.join(file_path_feat, self.txt_skl_shaft_vectices),skeleton_p, fmt='%f')
  1139. tree = KDTree(skeleton_p)
  1140. dist, _= tree.query(vertices_00 )
  1141. np.savetxt(os.path.join(file_path_feat, self.txt_skl_shaft_distance),dist, fmt='%f')
  1145. def get_head_neck_segss(self,
  1146. spine_shaft_txt,
  1147. path_train,
  1148. metrics,
  1149. seg_dend='full',
  1150. pre_portion=None,
  1151. zoom_thre=25,
  1152. skip_first_n=1,
  1153. skip_end_n=10,
  1154. subdivision_thre=3,
  1155. subsample_thre=.02,
  1156. f=0.99,
  1157. N=10,
  1158. num_chunks=100,
  1159. line_num_points=None,
  1160. line_num_points_inter=None,
  1161. spline_smooth=None,
  1162. num_points=50,
  1163. ctl_run_thre=1,
  1164. size_threshold=None ,
  1165. end_thre=40,
  1166. get_refine_=False,
  1167. head_neck_path='dest_spine_path',
  1168. smooth_tf=False,
  1169. dict_mesh_to_skeleton_finder_mesh=None,
  1170. ):
  1171. line_num_points=line_num_points or self.line_num_points_shaft
  1172. line_num_points_inter=line_num_points_inter or self.line_num_points_inter_shaft
  1173. spline_smooth=spline_smooth or self.spline_smooth_shaft
  1174. data_shaft_path=self.path_file[path_train['data_spine_path']]
  1175. dest_shaft_path=self.path_file[path_train['dest_shaft_path']]
  1176. spine_path_new_pre=self.path_file[path_train['dest_spine_path_pre']]
  1177. shaft_vertices_center_path=self.path_file[path_train['data_spine_path_center']]
  1178. shaft_vertices_center_path_dest=self.path_file[path_train['dest_spine_path_center']]
  1179. dest_spine_path_pre_init=self.path_file[path_train['dest_spine_path_pre_init']]
  1180. spine_path_new=dest_spine_path_new=self.path_file[path_train[head_neck_path]]
  1181. pre_save_txt= False if head_neck_path=='dest_spine_path_pre' else True
  1184. self.get_dend_data()
  1185. dist_norm=dist_norm_gen=np.loadtxt(os.path.join(self.file_path_feat, self.txt_skl_distance))
  1186. n_vert=len(dist_norm_gen)
  1187. dist_norm=np.loadtxt(os.path.join(self.file_path_feat, f'kmean_4.txt')).astype(int)
  1189. intensity_org_neck_head = np.zeros(n_vert)
  1190. intensity_pca={}
  1191. self.metric_save={}
  1192. for key in self.inten_pca:
  1193. intensity_pca[key]=np.zeros(n_vert)
  1194. skl_vectices= np.loadtxt(os.path.join(self.file_path_feat, f'skl_vectices.txt'),dtype=float)
  1195. inten=np.loadtxt(os.path.join(self.file_path_feat, f'kmean_10.txt')).astype(int)
  1196. reg=region_branch(region_index=inten,dend=self.dend,skl_vectices=skl_vectices)
  1197. reg.get_skl_smooth(
  1198. line_num_points=10,
  1199. line_num_points_inter=30,
  1200. spline_smooth=0.75)
  1201. count= hff.loadtxt_count(os.path.join(spine_path_new,self.txt_spine_count))
  1202. mmm=count.ndim
  1203. count=count if mmm==2 else count.reshape(-1,1)
  1204. for idx in range(count.shape[0]):
  1205. ii=count[idx,0]
  1206. name=f'{ii}_{count[idx,1]}' if mmm==2 else f'{ii}'
  1207. dname=f'{self.dend_first_name}_sy{name}'
  1209. if ii<0:
  1210. name=f'0_0'
  1211. dname=f'{self.dend_first_name}_sy{name}'
  1212. spine_index=self.dend.vertices
  1213. spine_faces=self.dend.faces
  1214. np.savetxt(os.path.join(spine_path_new, f'{self.name_spine}_{self.name_index}_{name}.txt'), spine_index, fmt='%d')
  1215. np.savetxt(os.path.join(spine_path_new, f'{self.name_spine}_{self.name_faces}_{name}.txt'), spine_faces, fmt='%d')
  1216. np.savetxt(os.path.join(spine_path_new, f'spine_{self.name_count}.txt'), [[0,0]], fmt='%d')
  1217. else:
  1218. spine_index = np.loadtxt(os.path.join(spine_path_new, f'{self.name_spine}_{self.name_index}_{name}.txt'),dtype=int)
  1219. spine_faces = np.loadtxt(os.path.join(spine_path_new, f'{self.name_spine}_{self.name_faces}_{name}.txt'),dtype=int)
  1220. vertices_index_unique=np.loadtxt(os.path.join(spine_path_new, f'{self.name_spine_index_unique}_{name}.txt'),dtype=int)
  1221. loo=os.path.join( spine_path_new,f'{self.name_spine}_{self.name_center}_curv_{name}.txt')
  1222. if os.path.exists(loo):
  1223. vertices_center=np.loadtxt(loo,dtype=float)
  1224. else:
  1225. continue
  1226. vecty=dist_norm[spine_index]
  1227. vectyy=reg.intensity_thickness[spine_index]
  1228. arg_ver=np.argsort(vecty)
  1229. bvg=2*np.ones(len(spine_index))
  1230. bvg[vecty<=vecty[arg_ver[1]]]=1
  1231. intensity_org_neck_head[spine_index]=bvg
  1233. self.metric_save[name]={}
  1234. self.metric_save[name]['limit']=(0,0,0,0) if len(vectyy)<=0 else find_min_max_no_cross(vectyy)
  1235. vertices_head_index_set = set(np.where(intensity_org_neck_head == 2)[0])
  1236. vertices_neck_index_set = set(np.where(intensity_org_neck_head == 1)[0])
  1237. if (len(vertices_center)>3) and (len(spine_index)>0):
  1238. get_head_neck_mectric(self,self.metric_save,metrics,dname, name,spine_index,spine_faces,vertices_index_unique,vertices_center, vertices_head_index_set,vertices_neck_index_set,
  1239. subsample_thre=subsample_thre,
  1240. f=f,
  1241. N=N,
  1242. num_chunks=num_chunks,
  1243. num_points=num_points,
  1244. line_num_points= line_num_points,
  1245. line_num_points_inter= line_num_points_inter,
  1246. spline_smooth= spline_smooth,
  1247. ctl_run_thre=ctl_run_thre,
  1248. # node_head=node_head,
  1249. # node_neck=node_neck,
  1250. )
  1251. np.savetxt(os.path.join(spine_path_new, 'intensity_head_neck_segm.txt'),intensity_org_neck_head,fmt='%d')

help_pinn_data_222.py at commit 6dcc0e8, no license · at the source

Overview

Authors: Abdel Kader A Geraldo1, Michael A Chirillo2, Kristen M Harris3, Thomas G Fai4
ORCID iDs: Thomas G Fai
  1. Department of Mathematics, Brandeis University, Waltham, MA, USA
  2. Department of Biological Sciences, University of Rhode Island, Kingston, RI, USA
  3. Department of Neuroscience, University of Texas at Austin, Austin, TX, USA
  4. Department of Mathematics and Volen Center for Complex Systems, Brandeis University, Waltham, MA, USA
Institutions: Brandeis University (United States); University of Rhode Island (United States); The University of Texas at Austin (United States)
Journal: Biophysical journal, volume 125, issue 14, pages 3604-3619
Dates: received 29 December 2025; accepted 2 June 2026; published online 5 June 2026; in print 21 July 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1016/j.bpj.2026.06.005 · PMID 42249612 · PMCID PMC13335156 · OpenAlex W7163635577
Open access: hybrid, a free copy (OpenAlex)
Status: code verified
Categories: histology / microscopy (modality)
Methods: Smoothing, state filtering, decompositions, Machine learning
MeSH: Dendritic Spines*, Imaging, Three-Dimensional*, Machine Learning*, Animals, Automation (* major topic)
Topic: Medical Imaging and Analysis (Biomedical Engineering, Engineering), according to OpenAlex
Funding: NIMH NIH HHS (R56 MH139176, R01 MH095980); NINDS NIH HHS (T32 NS007292); National Science Foundation; National Institutes of Health
Citations: not cited yet (Europe PMC); 66 references in the paper

Abstract

Recent advances in connectomics have been led by high-resolution reconstruction of large volumes of neural tissues using electron microscopy (EM), providing unprecedented insights into brain structure and function. Dendritic spines—dynamic protrusions on neuronal dendrites—play crucial roles in synaptic plasticity, influencing learning, memory, and various neurological disorders. However, current spine-analysis methods often rely on manual annotation of subcellular features, limiting their ability to handle the complexity of spines in dense dendritic networks. This paper introduces a novel automated computational framework that integrates discrete differential geometry, machine learning, and 3D image processing to analyze dendritic spines in these intricate environments. By generating distributions of spine morphology from high-resolution images including many thousands of spines, our approach captures subtle variations in spine shapes, offering a nuanced understanding of their roles in synaptic function. This framework is tested on multiple EM datasets with the aim of enhancing our understanding of synaptic plasticity and its alterations in disease states. The proposed method is poised to accelerate neuroscience research by providing a scalable, objective, and comprehensive solution for spine analysis, uncovering insights into the role of spine geometry for neural function.

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

Repositories

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

aka-gera/curvature-based-machine-learning-for-automated-segmentation-of-dendritic-spines

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 6dcc0e8463d84c4ec2e852e226a6e1635db5e0ed, 4 June 2026
Languages: Python (44), Jupyter (1), Shell (1)
Size: 146 files, 46 scripts
Software Heritage: not archived
Found in: “Data availability”
Holds: README, environment (requirements.txt, requirements_win.txt, dend_analysis/app/requirements.txt), 1 notebook
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (34 files), scikit-learn (20 files), SciPy (13 files), TensorFlow (12 files), Keras (9 files), Plotly (9 files), pandas (5 files), NetworkX (2 files), scikit-image (2 files), Matplotlib (1 file), SHAP (1 file), XGBoost (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
47 files
At the source: github.com/aka-gera/curvature-based-machine-learning-for-automated-segmentation-of-dendritic-spines

Zenodo 19593999

License: CC-BY-4.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Size: 3 files
Software Heritage: not checked
Found in: “Data availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 27 September 2026: the link answers (HTTP 200)
  • 27 September 2026: the link answers (HTTP 200)
At the source: doi.org/10.5281/zenodo.19593999

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;
  • 46 scripts, each with its path and the digest of its content;
  • 7 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

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

Data

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

Data availability

To make these methods widely accessible, we have posted an open-source code repository on GitHub (GitHub:curvature-based-dendrite-segmentation (https://github.com/aka-gera/curvature-based-machine-learning-for-automated-segmentation-of-dendritic-spines)), with the trained model, training data, and validation data made available in a linked repository (Zenodo: https://doi.org/10.5281/zenodo.19593999).

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

  • Authors: added Thomas G Fai (0000-0003-0383-5217); removed Thomas G Fai

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 4 authors, 5 MeSH terms, 4 funders, 36 references.

Cite

This paper

Geraldo, A. K. A., Chirillo, M. A., Harris, K. M., & Fai, T. G. (2026). Curvature-based machine-learning method for automated segmentation of dendritic spines. Biophysical journal, 125(14), 3604-3619. https://doi.org/10.1016/j.bpj.2026.06.005

BibTeX

@article{geraldo2026curvature,
author = {Geraldo, Abdel Kader A and Chirillo, Michael A and Harris, Kristen M and Fai, Thomas G},
title = {{Curvature-based machine-learning method for automated segmentation of dendritic spines}},
journal = {Biophysical journal},
year = {2026},
month = jun,
volume = {125},
number = {14},
pages = {3604--3619},
publisher = {Elsevier BV},
issn = {0006-3495},
doi = {10.1016/j.bpj.2026.06.005},
url = {https://doi.org/10.1016/j.bpj.2026.06.005},
pmid = {42249612},
pmcid = {PMC13335156}
}

RIS

TY - JOUR
AU - Geraldo, Abdel Kader A
AU - Chirillo, Michael A
AU - Harris, Kristen M
AU - Fai, Thomas G
TI - Curvature-based machine-learning method for automated segmentation of dendritic spines
T2 - Biophysical journal
J2 - Biophys J
PY - 2026
DA - 2026/06/05
VL - 125
IS - 14
SP - 3604
EP - 3619
SN - 0006-3495
PB - Elsevier BV
DO - 10.1016/j.bpj.2026.06.005
UR - https://doi.org/10.1016/j.bpj.2026.06.005
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.bpj.2026.06.005",
"type": "article-journal",
"title": "Curvature-based machine-learning method for automated segmentation of dendritic spines",
"container-title": "Biophysical journal",
"author": [
{
"family": "Geraldo",
"given": "Abdel Kader A"
},
{
"family": "Chirillo",
"given": "Michael A"
},
{
"family": "Harris",
"given": "Kristen M"
},
{
"family": "Fai",
"given": "Thomas G"
}
],
"container-title-short": "Biophys J",
"volume": "125",
"issue": "14",
"page": "3604-3619",
"DOI": "10.1016/j.bpj.2026.06.005",
"PMID": "42249612",
"PMCID": "PMC13335156",
"ISSN": "0006-3495",
"publisher": "Elsevier BV",
"URL": "https://doi.org/10.1016/j.bpj.2026.06.005",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
5
]
]
}
}

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.1371/journal.pcbi.1014571 [code]
SynAPSeg: A novel dataset and image analysis framework for deep learning-based synapse detection and quantification.
Journal: PLoS computational biology
In common: Keras, TensorFlow, NetworkX, 6 other tools, 5 references
[2] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: SHAP, XGBoost, Keras, 9 other tools
[3] doi:10.1126/sciadv.aed3650 [code]
Truthful visualizations for mass spectrometry imaging enable high-spatial-resolution interactive &lt;i&gt;m/z&lt;/i&gt; mapping and exploration.
Journal: Science advances
In common: SHAP, XGBoost, Keras, 8 other tools
[4] doi:10.1038/s41598-026-48613-0 [code]
An snRNA-seq aging clock for the fruit fly head sheds light on sex-biased aging.
Journal: Scientific reports
In common: SHAP, XGBoost, Keras, 6 other tools, 2 references
[5] doi:10.1016/j.isci.2026.117010 [code]
Deep learning-assisted mapping of dendritic spines using sequential 2D two-photon calcium imaging.
Journal: iScience
In common: TensorFlow, scikit-image, scikit-learn, 4 other tools, histology / microscopy, 3 references
[6] doi:10.1016/j.isci.2026.116825 [code]
Social hierarchy shapes behavioral and transcriptional responses to chronic stress and ketamine in male mice.
Journal: iScience
In common: SHAP, XGBoost, NetworkX, 7 other tools
[7] doi:10.1016/j.celrep.2026.117793 [code]
Clustered inputs engage dendritic nonlinearities and calcium signaling to support efficient place-field formation in CA1 pyramidal neurons.
Journal: Cell reports
In common: SHAP, scikit-learn, pandas, 3 other tools, 4 references
[8] doi:10.3389/fnsys.2026.1822122 [code]
Convergence-divergence circuits for multimodal integration of innate and learned opponent valences.
Journal: Frontiers in systems neuroscience
In common: Keras, TensorFlow, NetworkX, 7 other tools
[9] doi:10.1016/j.xcrm.2026.102766 [code]
A longitudinal single-cell and spatial multiomic atlas of pediatric high-grade glioma.
Journal: Cell reports. Medicine
In common: Keras, TensorFlow, NetworkX, 7 other tools
[10] doi:10.3390/s26175327 [code]
Subject Identity Confounds qEEG Emotion Recognition on DEAP and DREAMER.
Journal: Sensors (Basel, Switzerland)
In common: SHAP, XGBoost, Keras, 6 other tools

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.