def load_contours():
contours = mu.Bag({hemi: None for hemi in mu.HEMIS})
for hemi in mu.HEMIS:
verts_num = len(bpy.data.objects[hemi].data.vertices)
contours[hemi] = mu.Bag(
dict(contours=np.zeros(verts_num), labels=[], max=0))
contours_fnames = glob.glob(
op.join(
mu.get_user_fol(), 'labels',
'clusters-{}*_contours_{}.npz'.format(
bpy.context.scene.meg_clusters_labels_files, hemi)))
for contours_fname in contours_fnames:
d = np.load(contours_fname)
# print(contours_fname, d['labels'], np.unique(d['contours']))
contours_data = d['contours']
contours_data[np.where(contours_data)] += len(
contours[hemi].labels)
contours[hemi].contours += contours_data
labels = [l for l in d['labels'] if 'unknown' not in l]
contours[hemi].labels.extend(labels)
for hemi in mu.HEMIS:
contours[hemi].max = len(contours[hemi].labels)
# print('contours in {} {}: {}'.format(hemi, bpy.context.scene.meg_clusters_labels_files,
# np.unique(contours[hemi].contours)))
MEGPanel.contours = contours
def load_clusters_file(clusters_name=''):
if clusters_name == '':
clusters_name = bpy.context.scene.meg_clusters_labels_files
fname = MEGPanel.clusters_labels_fnames[clusters_name]
c = mu.Bag(mu.load(fname))
for ind in range(len(c.values)):
c.values[ind] = mu.Bag(c.values[ind])
return c
def init(addon):
user_fol = mu.get_user_fol()
# clusters_labels_files = glob.glob(op.join(user_fol, 'fmri', 'clusters_labels_*.pkl'))
# old code was saving those files as npy instead of pkl
# clusters_labels_files.extend(glob.glob(op.join(user_fol, 'fmri', 'clusters_labels_*.npy')))
# fmri_blobs = glob.glob(op.join(user_fol, 'fmri', 'blobs_*_rh.npy'))
fMRIPanel.addon = addon
fMRIPanel.lookup, fMRIPanel.clusters_labels = {}, {}
fMRIPanel.cluster_labels = {}
files_names, clusters_labels_files, clusters_labels_items = get_clusters_files(
user_fol)
fMRIPanel.fMRI_clusters_files_exist = len(
files_names) > 0 # and len(fmri_blobs) > 0
if not fMRIPanel.fMRI_clusters_files_exist:
register()
fMRIPanel.init = True
return
# files_names = [mu.namebase(fname)[len('clusters_labels_'):] for fname in clusters_labels_files]
fMRIPanel.clusters_labels_file_names = files_names
bpy.types.Scene.fmri_clusters_labels_files = bpy.props.EnumProperty(
items=clusters_labels_items,
description="fMRI files",
update=fmri_clusters_labels_files_update)
bpy.context.scene.fmri_clusters_labels_files = files_names[0]
bpy.context.scene.plot_fmri_cluster_contours = False
for file_name, clusters_labels_file in zip(files_names,
clusters_labels_files):
# Check if the constrast files exist
if all(
[get_contrast_fname(file_name, hemi) != '' for hemi in mu.HEMIS]):
key = file_name
fMRIPanel.clusters_labels[key] = c = mu.Bag(
mu.load(clusters_labels_file))
for ind in range(len(c.values)):
c.values[ind] = mu.Bag(c.values[ind])
fMRIPanel.lookup[key] = create_lookup_table(
fMRIPanel.clusters_labels[key])
# bpy.context.scene.fmri_cluster_val_threshold = 2
# bpy.context.scene.fmri_cluster_size_threshold = 20
bpy.context.scene.search_closest_cluster_only_in_filtered = True
bpy.context.scene.fmri_what_to_plot = 'blob'
bpy.context.scene.fmri_how_to_sort = 'tval'
bpy.context.scene.plot_current_cluster = True
update_clusters()
fMRIPanel.blobs_activity, _ = calc_blobs_activity(
fMRIPanel.constrast, fMRIPanel.clusters_labels_filtered,
fMRIPanel.colors_in_hemis)
bpy.context.scene.plot_fmri_cluster_per_click = False
fMRIPanel.dont_show_clusters_info = True
# addon.clear_cortex()
register()
fMRIPanel.init = True
def init(addon):
try:
trans_fname = op.join(mu.get_user_fol(), 'orig_trans.npz')
volumes = glob.glob(
op.join(mu.get_user_fol(), 'freeview', '*+aseg.npy'))
luts = glob.glob(
op.join(mu.get_user_fol(), 'freeview', '*ColorLUT.npz'))
if op.isfile(trans_fname):
WhereAmIPanel.subject_orig_trans = mu.Bag(np.load(trans_fname))
for atlas_vol_fname, atlas_vol_lut_fname in zip(volumes, luts):
atlas = mu.namebase(atlas_vol_fname)[:-len('+aseg')]
WhereAmIPanel.vol_atlas[atlas] = np.load(atlas_vol_fname)
WhereAmIPanel.vol_atlas_lut[atlas] = np.load(atlas_vol_lut_fname)
subjects_dir = mu.get_link_dir(mu.get_links_dir(), 'subjects')
annot_files = glob.glob(
op.join(subjects_dir, mu.get_user(), 'label', 'rh.*.annot'))
if len(annot_files) > 0:
files_names = [mu.namebase(fname)[3:] for fname in annot_files]
items = [(c, c, '', ind) for ind, c in enumerate(files_names)]
bpy.types.Scene.subject_annot_files = bpy.props.EnumProperty(
items=items)
bpy.context.scene.subject_annot_files = files_names[0]
else:
bpy.types.Scene.subject_annot_files = bpy.props.EnumProperty(
items=[])
# bpy.context.scene.subject_annot_files = ''
bpy.context.scene.closest_label_output = ''
bpy.context.scene.new_label_r = 5
mri_data_fname = op.join(mu.get_user_fol(), 'freeview',
'{}_data.npz'.format('mri'))
if op.isfile(mri_data_fname):
WhereAmIPanel.mri_data = mu.Bag(np.load(mri_data_fname))
gray_colormap_fname = op.join(mu.file_fol(), 'color_maps', 'gray.npy')
if op.isfile(gray_colormap_fname):
WhereAmIPanel.gray_colormap = np.load(gray_colormap_fname)
WhereAmIPanel.addon = addon
WhereAmIPanel.init = True
WhereAmIPanel.run_slices_listener = False
init_slices()
if WhereAmIPanel.run_slices_listener:
start_slicer_server()
else:
WhereAmIPanel.slicer_state = slicer.init('mri')
create_slices('mri', bpy.context.scene.cursor_location)
save_slices_cursor_pos()
register()
except:
print("Can't init where-am-I panel!")
print(traceback.format_exc())
def init(modality, modality_data=None, colormap=None, subject='', mmvt_dir=''):
if subject == '':
subject = mu.get_user()
if mmvt_dir == '':
mmvt_dir = mu.file_fol()
if modality_data is None:
if modality == 'mri':
fname = op.join(mmvt_dir, subject, 'freeview', 'mri_data.npz')
elif modality == 't2':
fname = op.join(mmvt_dir, subject, 'freeview', 't2_data.npz')
elif modality == 'ct':
fname = op.join(mmvt_dir, subject, 'ct', 'ct_data.npz'.format(modality))
if op.isfile(fname):
modality_data = mu.Bag(np.load(fname))
else:
print('To see the slices the following command is being called:'.format(modality))
print('python -m src.preproc.anatomy -s {} -f save_images_data_and_header'.format(mu.get_user()))
mu.run_mmvt_func('src.preproc.anatom', 'save_subject_orig_trans,save_images_data_and_header')
# cmd = '{} -m src.preproc.anatomy -s {} -f save_subject_orig_trans,save_images_data_and_header --ignore_missing 1'.format(
# bpy.context.scene.python_cmd, mu.get_user())
# mu.run_command_in_new_thread(cmd, False, cwd=mu.get_mmvt_code_root())
return None
if colormap is None:
if op.isfile(op.join(mmvt_dir, 'color_maps', 'gray.npy')):
colormap_fname = op.join(mmvt_dir, 'color_maps', 'gray.npy')
print("Can't find The gray colormap!")
else:
colormap_fname = glob.glob(op.join(mmvt_dir, 'color_maps', '*.npy'))[0]
colormap = np.load(colormap_fname)
affine = np.array(modality_data.affine, float)
data = modality_data.data
clim = modality_data.precentiles
if IN_BLENDER:
bpy.context.scene.slices_x_min, bpy.context.scene.slices_x_max = clim
colors_ratio = modality_data.colors_ratio
codes = axcodes2ornt(aff2axcodes(affine))
order = np.argsort([c[0] for c in codes])
print(modality, order)
flips = np.array([c[1] < 0 for c in codes])[order]
flips[0] = not flips[0]
sizes = [data.shape[order] for order in order]
scalers = voxel_sizes(affine)
r = [scalers[order[2]] / scalers[order[1]],
scalers[order[2]] / scalers[order[0]],
scalers[order[1]] / scalers[order[0]]]
extras = [0] * 3
pial_vol_mask_fname = op.join(mmvt_dir, subject, 'freeview', 'pial_vol_mask.npy')
pial_vol_mask = np.load(pial_vol_mask_fname) if op.isfile(pial_vol_mask_fname) else None
self = mu.Bag(dict(
data=data, affine=affine, order=order, sizes=sizes, flips=flips, clim=clim, r=r, colors_ratio=colors_ratio,
colormap=colormap, coordinates=[], modality=modality, extras=extras, pial_vol_mask=pial_vol_mask))
return self
def load_connections_file():
d, vertices, vertices_lookup = None, None, None
conn_file_name = bpy.context.scene.connectivity_files.replace(' ', '_')
connectivity_file = op.join(mu.get_user_fol(), 'connectivity', '{}.npz'.format(conn_file_name))
vertices_file = op.join(mu.get_user_fol(), 'connectivity', '{}_vertices.pkl'.format(
conn_file_name.replace('_static', '')))
if op.isfile(connectivity_file):
print('loading connectivity: {}'.format(connectivity_file))
d = mu.Bag(np.load(connectivity_file))
d.labels = [l.astype(str) for l in d.labels]
d.hemis = [l.astype(str) for l in d.hemis]
d.con_names = np.array([l.astype(str) for l in d.con_names], dtype=np.str)
d.conditions = [l.astype(str) for l in d.conditions]
if d.con_values.ndim == 2:
d.con_values = d.con_values[:, :, np.newaxis]
conditions_items = [(cond, cond, '', cond_ind) for cond_ind, cond in enumerate(d.conditions)]
if len(d.conditions) > 1:
diff_cond = '{}-{} difference'.format(d.conditions[0], d.conditions[1])
conditions_items.append((diff_cond, diff_cond, '', len(d.conditions)))
bpy.types.Scene.conditions = bpy.props.EnumProperty(items=conditions_items, description="Conditions")
# bpy.context.scene.connections_max, bpy.context.scene.connections_min = d['data_max'], d['data_min']
else:
print('No connections file! {}'.format(connectivity_file))
if op.isfile(vertices_file):
vertices, vertices_lookup = mu.load(vertices_file)
else:
name_parts = mu.namebase(vertices_file).split('_')
vertices_files = glob.glob(
op.join(mu.get_parent_fol(vertices_file), '{}*_{}.pkl'.format(name_parts[0], name_parts[-1])))
if len(vertices_files) == 1:
vertices, vertices_lookup = mu.load(vertices_files[0])
else:
print('No vertices file! ({})'.format(vertices_file))
ConnectionsPanel.d, ConnectionsPanel.vertices, ConnectionsPanel.vertices_lookup = d, vertices, vertices_lookup
def init(modality, modality_data=None, colormap=None):
if modality_data is None:
fname = op.join(mu.get_user_fol(), 'freeview',
'{}_data.npz'.format(modality))
if op.isfile(fname):
modality_data = mu.Bag(np.load(fname))
else:
print(
'To see the slices you need to create the file {}_data.npz by calling:'
.format(modality))
print(
'python -m src.preproc.anatomy -s {} -f save_images_data_and_header'
.format(mu.get_user()))
return None
if colormap is None:
colormap_fname = op.join(mu.file_fol(), 'color_maps', 'gray.npy')
colormap = np.load(colormap_fname)
affine = np.array(modality_data.affine, float)
data = modality_data.data
clim = modality_data.precentiles
colors_ratio = modality_data.colors_ratio
codes = axcodes2ornt(aff2axcodes(affine))
order = np.argsort([c[0] for c in codes])
flips = np.array([c[1] < 0 for c in codes])[order]
flips[0] = not flips[0]
sizes = [data.shape[order] for order in order]
scalers = voxel_sizes(affine)
r = [
scalers[order[2]] / scalers[order[1]],
scalers[order[2]] / scalers[order[0]],
scalers[order[1]] / scalers[order[0]]
]
self = mu.Bag(
dict(data=data,
affine=affine,
order=order,
sizes=sizes,
flips=flips,
clim=clim,
r=r,
colors_ratio=colors_ratio,
colormap=colormap))
return self
class ConnectionsPanel(bpy.types.Panel):
bl_space_type = "GRAPH_EDITOR"
bl_region_type = "UI"
bl_context = "objectmode"
bl_category = "mmvt"
bl_label = "Connections"
addon = None
d = mu.Bag({})
show_connections = True
do_filter = True
def draw(self, context):
connections_draw(self, context)
def replot_contours():
for hemi in mu.HEMIS:
input_fname = op.join(mu.get_user_fol(), 'labels',
'last_contours_{}.npz'.format(hemi))
if not op.isfile(input_fname):
continue
cont_data = mu.Bag(np.load(input_fname, allow_pickle=True))
_addon().color_hemi_data(hemi,
cont_data.selected_contours,
cont_data.data_min,
256 / cont_data.contour_max,
override_current_mat=not cont_data.cumulate,
coloring_layer='contours',
check_valid_verts=False)
def plot_distances_from_outer():
f = mu.Bag(
np.load(
op.join(mu.get_user_fol(), 'skull',
'intersections_from_outer_skull.npz')))
distances = np.linalg.norm(f.intersections[:, 0] - f.intersections[:, 1],
axis=1)
faces_verts = np.load(
op.join(mu.get_user_fol(), 'skull', 'faces_verts_outer_skull.npy'))
outer_skull = bpy.data.objects['outer_skull']
data_max = np.percentile(distances, 75)
if _addon().colorbar_values_are_locked():
data_max, data_min = _addon().get_colorbar_max_min()
else:
_addon().set_colorbar_max_min(data_max, 0)
colors_ratio = 256 / data_max
_addon().activity_map_obj_coloring(outer_skull, distances, faces_verts, 0,
True, 0, colors_ratio)
def load_connections_file():
if op.isfile(bpy.context.scene.connections_file):
print('loading {}'.format(bpy.context.scene.connections_file))
d = mu.Bag(np.load(bpy.context.scene.connections_file))
d.labels = [l.astype(str) for l in d.labels]
d.hemis = [l.astype(str) for l in d.hemis]
d.con_names = np.array([l.astype(str) for l in d.con_names],
dtype=np.str)
d.conditions = [l.astype(str) for l in d.conditions]
ConnectionsPanel.d = d
conditions_items = [(cond, cond, '', cond_ind)
for cond_ind, cond in enumerate(d.conditions)]
if len(d.conditions) > 1:
diff_cond = '{}-{} difference'.format(d.conditions[0],
d.conditions[1])
conditions_items.append(
(diff_cond, diff_cond, '', len(d.conditions)))
bpy.types.Scene.conditions = bpy.props.EnumProperty(
items=conditions_items, description="Conditions")
else:
print('No connections file!')
def init(addon):
try:
t1_trans_fname = op.join(mu.get_user_fol(), 't1_trans.npz')
if not op.isfile(t1_trans_fname):
# backward compatibility
t1_trans_fname = op.join(mu.get_user_fol(), 'orig_trans.npz')
t2_trans_fname = op.join(mu.get_user_fol(), 't2_trans.npz')
ct_trans_fname = op.join(mu.get_user_fol(), 'ct', 'ct_trans.npz')
volumes = glob.glob(op.join(mu.get_user_fol(), 'freeview', '*+aseg.npy'))
luts = glob.glob(op.join(mu.get_user_fol(), 'freeview', '*ColorLUT.npz'))
if op.isfile(t1_trans_fname):
WhereAmIPanel.subject_t1_trans = mu.Bag(np.load(t1_trans_fname))
if op.isfile(t2_trans_fname):
WhereAmIPanel.subject_t2_trans = mu.Bag(np.load(t2_trans_fname))
if op.isfile(ct_trans_fname):
WhereAmIPanel.subject_ct_trans = mu.Bag(np.load(ct_trans_fname))
for atlas_vol_fname, atlas_vol_lut_fname in zip(volumes, luts):
atlas = mu.namebase(atlas_vol_fname)[:-len('+aseg')]
WhereAmIPanel.vol_atlas[atlas] = np.load(atlas_vol_fname)
WhereAmIPanel.vol_atlas_lut[atlas] = np.load(atlas_vol_lut_fname)
try:
subjects_dir = mu.get_link_dir(mu.get_links_dir(), 'subjects')
annot_files = [mu.namebase(fname)[3:] for fname in glob.glob(
op.join(subjects_dir, mu.get_user(), 'label', 'rh.*.annot'))]
annot_files += [mu.namebase(fname)[3:] for fname in glob.glob(
op.join(mu.get_user_fol(), 'labels', 'rh.*.annot'))]
WhereAmIPanel.annot_files = annot_files = list(set(annot_files))
if len(annot_files) > 0:
items = [(c, c, '', ind) for ind, c in enumerate(annot_files)]
bpy.types.Scene.subject_annot_files = bpy.props.EnumProperty(
items=items, update=subject_annot_files_update, description='List of different atlases.\n\nCurrent atlas')
ind = mu.index_in_list(bpy.context.scene.atlas, annot_files, 0)
bpy.context.scene.subject_annot_files = annot_files[ind]
else:
bpy.types.Scene.subject_annot_files = bpy.props.EnumProperty(items=[])
# bpy.context.scene.subject_annot_files = ''
except:
bpy.types.Scene.subject_annot_files = bpy.props.EnumProperty(items=[])
bpy.context.scene.closest_label_output = ''
bpy.context.scene.new_label_r = 5
bpy.context.scene.find_closest_label_on_click = False
bpy.context.scene.plot_closest_label_contour = False
mri_data_fname = op.join(mu.get_user_fol(), 'freeview', 'mri_data.npz')
if op.isfile(mri_data_fname):
WhereAmIPanel.mri_data = mu.Bag(np.load(mri_data_fname))
gray_colormap_fname = op.join(mu.file_fol(), 'color_maps', 'gray.npy')
if op.isfile(gray_colormap_fname):
WhereAmIPanel.gray_colormap = np.load(gray_colormap_fname)
WhereAmIPanel.addon = addon
WhereAmIPanel.init = True
WhereAmIPanel.run_slices_listener = False
init_slices()
if WhereAmIPanel.run_slices_listener:
start_slicer_server()
else:
WhereAmIPanel.slicer_state = mu.Bag({})
WhereAmIPanel.slicer_state['mri'] = slicer.init(_addon(), 'mri')
create_slices(None, bpy.context.scene.cursor_location)
save_slices_cursor_pos()
register()
except:
print("Can't init where-am-I panel!")
print(traceback.format_exc())
def create_slices(xyz,
state=None,
modalities='mri',
modality_data=None,
colormap=None,
plot_cross=True,
zoom_around_voxel=False,
zoom_voxels_num=30,
smooth=False,
clim=None,
mark_voxel=True):
self = mu.Bag({})
if isinstance(modalities, str):
modalities = [modalities]
# modalities = set(modalities)
# if 'mri' not in modalities:
# modalities.append('mri')
for modality in modalities:
if state is None or modality not in state:
self[modality] = init(modality, modality_data, colormap)
else:
self[modality] = state[modality]
mri = state['mri']
if mri is None:
return None
# print(xyz)
xyz = np.rint(xyz).astype(int)
x, y, z = xyz[:3]
for modality in modalities:
self[modality].coordinates = np.rint(
np.array([x, y, z])[self[modality].order]).astype(int)
self[modality].cross = [None] * 3
self[modality].x_vox = np.zeros_like(self[modality].data)
if mu.in_shape(xyz, self[modality].data.shape):
self[modality].x_vox[tuple(xyz)] = 255
else:
self[modality].x_vox[128, 128, 128] = 255
# cross_vert, cross_horiz = calc_cross(self[modality].coordinates, self[modality].sizes, self[modality].flips)
images = {}
xaxs, yaxs = [1, 0, 0], [2, 2, 1]
max_xaxs_size = max([
self[modality].sizes[xax]
for xax, modality in product(yaxs, modalities)
])
max_yaxs_size = max([
self[modality].sizes[yax]
for yax, modality in product(yaxs, modalities)
])
max_sizes = (max_xaxs_size, max_yaxs_size)
for ii, xax, yax, prespective, label in zip(
[0, 1, 2], xaxs, yaxs, ['sagital', 'coronal', 'axial'],
('SAIP', 'SLIR', 'ALPR')):
pixels = {}
# cross = (int(cross_horiz[ii][0, 1]), int(cross_vert[ii][0, 0]))
# print('cross', cross)
# self[modality].cross[ii] = cross
for modality in modalities:
s = self[modality]
cross = calc_cross(self[modality].x_vox, s, ii)
# print('{} ({},{})'.format(prespective, cross[0], cross[1]))
self[modality].cross[ii] = cross
d = get_image_data(s.data, s.order, s.flips, ii, s.coordinates,
cross, zoom_around_voxel, zoom_voxels_num,
smooth)
if s.pial_vol_mask is not None and bpy.context.scene.slices_show_pial:
pial_vol_mask_data = get_image_data(s.pial_vol_mask, s.order,
s.flips, ii, s.coordinates,
cross, zoom_around_voxel,
zoom_voxels_num, smooth)
else:
pial_vol_mask_data = None
if s.dural_vol_mask is not None and bpy.context.scene.slices_show_dural:
dural_vol_mask_data = get_image_data(s.dural_vol_mask, s.order,
s.flips, ii,
s.coordinates, cross,
zoom_around_voxel,
zoom_voxels_num, smooth)
else:
dural_vol_mask_data = None
# todo: Should do that step in the state init
if modality == 'ct':
d[np.where(d == 0)] = -200
sizes = (s.sizes[xax], s.sizes[yax])
self[modality].extras[ii] = (int((max_sizes[0] - sizes[0]) / 2),
int((max_sizes[1] - sizes[1]) / 2))
if clim is not None:
colors_ratio = 256 / (clim[1] - clim[0])
else:
clim, colors_ratio = s.clim, s.colors_ratio
pixels[modality] = calc_slice_pixels(d, sizes, max_sizes, clim,
colors_ratio, s.colormap,
zoom_around_voxel,
zoom_voxels_num, mark_voxel,
pial_vol_mask_data,
dural_vol_mask_data)
# image = create_image(d, sizes, max_sizes, s.clim, s.colors_ratio, prespective, s.colormap,
# int(cross_horiz[ii][0, 1]), int(cross_vert[ii][0, 0]),
# state[modality].extras[ii])
if 'mri' in modalities and 'ct' in modalities:
ct_ratio = bpy.context.scene.slices_modality_mix
pixels = (1 - ct_ratio) * pixels['mri'] + ct_ratio * pixels['ct']
else:
pixels = pixels[modality]
if plot_cross:
if zoom_around_voxel:
cross = (128, 128)
extra = (0, 0) if zoom_around_voxel else state[modality].extras[ii]
pixels = add_cross_to_pixels(pixels, max_sizes, cross, extra)
if IN_BLENDER:
image = create_image(pixels, max_sizes, prespective)
if image is not None:
images[prespective] = image
else:
images[prespective] = pixels
# print(np.dot(state[modality].affine, [x, y, z, 1])[:3])
return images
def get_report_fields():
fields = ReportsPanel.fields_values[bpy.context.scene.reports_files].copy()
fields = {k.lower().replace(' ', '_'): v for k, v in fields.items()}
return mu.Bag(fields)
