def grab_camera(self=None, do_save=True):
RenderFigure.update_camera = False
bpy.context.scene.X_rotation = X_rotation = math.degrees(
bpy.data.objects['Camera'].rotation_euler.x)
bpy.context.scene.Y_rotation = Y_rotation = math.degrees(
bpy.data.objects['Camera'].rotation_euler.y)
bpy.context.scene.Z_rotation = Z_rotation = math.degrees(
bpy.data.objects['Camera'].rotation_euler.z)
bpy.context.scene.X_location = X_location = bpy.data.objects[
'Camera'].location.x
bpy.context.scene.Y_location = Y_location = bpy.data.objects[
'Camera'].location.y
bpy.context.scene.Z_location = Z_location = bpy.data.objects[
'Camera'].location.z
if do_save:
if op.isdir(bpy.path.abspath(bpy.context.scene.output_path)):
camera_fname = op.join(
bpy.path.abspath(bpy.context.scene.output_path), 'camera.pkl')
mu.save((X_rotation, Y_rotation, Z_rotation, X_location,
Y_location, Z_location), camera_fname)
print('Camera location was saved to {}'.format(camera_fname))
else:
mu.message(
self, "Can't find the folder {}".format(
bpy.path.abspath(bpy.context.scene.output_path)))
RenderFigure.update_camera = True
def find_fmri_files_min_max():
_addon().lock_colorbar_values()
abs_values = []
for constrast_name in fMRIPanel.clusters_labels_file_names:
constrast = {}
constrasts_found = True
for hemi in mu.HEMIS:
contrast_fname = op.join(mu.get_user_fol(), 'fmri', 'fmri_{}_{}.npy'.format(constrast_name, hemi))
if not op.isfile(contrast_fname):
# Remove the atlas from the contrast name
new_constrast_name = '_'.join(constrast_name.split[:-1])
contrast_fname = op.join(mu.get_user_fol(), 'fmri', 'fmri_{}_{}.npy'.format(new_constrast_name, hemi))
if not op.isfile(contrast_fname):
constrasts_found = False
print("Can't find find_fmri_files_min_max for constrast_name!")
constrast[hemi] = np.load(contrast_fname)
if constrasts_found:
clusters_labels_filtered = filter_clusters(constrast_name)
blobs_activity, _ = calc_blobs_activity(constrast, clusters_labels_filtered)
data_max, data_min = get_activity_max_min(blobs_activity)
abs_values.extend([abs(data_max), abs(data_min)])
data_max = max(abs_values)
_addon().set_colorbar_max_min(data_max, -data_max)
cm_name = _addon().get_colormap()
output_fname = op.join(mu.get_user_fol(), 'fmri', 'fmri_files_minmax_cm.pkl')
mu.save((data_min, data_max, cm_name), output_fname)
def grab_camera(self=None, do_save=True, overwrite=True):
RenderFigure.update_camera = False
bpy.context.scene.X_rotation = X_rotation = math.degrees(
bpy.data.objects['Camera'].rotation_euler.x)
bpy.context.scene.Y_rotation = Y_rotation = math.degrees(
bpy.data.objects['Camera'].rotation_euler.y)
bpy.context.scene.Z_rotation = Z_rotation = math.degrees(
bpy.data.objects['Camera'].rotation_euler.z)
bpy.context.scene.X_location = X_location = bpy.data.objects[
'Camera'].location.x
bpy.context.scene.Y_location = Y_location = bpy.data.objects[
'Camera'].location.y
bpy.context.scene.Z_location = Z_location = bpy.data.objects[
'Camera'].location.z
if do_save:
if op.isdir(op.join(mu.get_user_fol(), 'camera')):
camera_fname = op.join(mu.get_user_fol(), 'camera', 'camera.pkl')
if not op.isfile(camera_fname) or overwrite:
mu.save((X_rotation, Y_rotation, Z_rotation, X_location,
Y_location, Z_location), camera_fname)
# print('Camera location was saved to {}'.format(camera_fname))
print((X_rotation, Y_rotation, Z_rotation, X_location,
Y_location, Z_location))
else:
mu.message(
self,
"Can't find the folder {}".format(mu.get_user_fol(), 'camera'))
RenderFigure.update_camera = True
def load_current_fmri_clusters_labels_file():
constrast_name = bpy.context.scene.fmri_clusters_labels_files
minmax_fname = op.join(
mu.get_user_fol(), 'fmri',
'{}_minmax.pkl'.format('_'.join(constrast_name.split('_')[:-1])))
minmax_exist = op.isfile(minmax_fname)
# if minmax_exist and not _addon().colorbar_values_are_locked():
# min_val, max_val = mu.load(minmax_fname)
# _addon().set_colorbar_max_min(max_val, min_val)
fMRIPanel.constrast = {}
for hemi in mu.HEMIS:
contrast_fname = get_contrast_fname(constrast_name, hemi)
if contrast_fname != '':
print('Loading {}'.format(contrast_fname))
fMRIPanel.constrast[hemi] = np.load(contrast_fname)
if not minmax_exist:
data = None
for hemi in mu.HEMIS:
x_ravel = fMRIPanel.constrast[hemi]
data = x_ravel if data is None else np.hstack((x_ravel, data))
norm_percs = (bpy.context.scene.fmri_blobs_percentile_min,
bpy.context.scene.fmri_blobs_percentile_max)
min_val, max_val = mu.calc_min_max(data, norm_percs=norm_percs)
_addon().colorbar.set_colorbar_max_min(max_val,
min_val,
force_update=True)
mu.save((min_val, max_val), minmax_fname)
def grab_camera(self=None, do_save=True):
RenderFigure.update_camera = False
bpy.context.scene.X_rotation = X_rotation = math.degrees(bpy.data.objects['Camera'].rotation_euler.x)
bpy.context.scene.Y_rotation = Y_rotation = math.degrees(bpy.data.objects['Camera'].rotation_euler.y)
bpy.context.scene.Z_rotation = Z_rotation = math.degrees(bpy.data.objects['Camera'].rotation_euler.z)
bpy.context.scene.X_location = X_location = bpy.data.objects['Camera'].location.x
bpy.context.scene.Y_location = Y_location = bpy.data.objects['Camera'].location.y
bpy.context.scene.Z_location = Z_location = bpy.data.objects['Camera'].location.z
if do_save:
if op.isdir(op.join(mu.get_user_fol(), 'camera')):
camera_fname = op.join(mu.get_user_fol(), 'camera', 'camera.pkl')
mu.save((X_rotation, Y_rotation, Z_rotation, X_location, Y_location, Z_location), camera_fname)
print('Camera location was saved to {}'.format(camera_fname))
else:
mu.message(self, "Can't find the folder {}".format(mu.get_user_fol(), 'camera'))
RenderFigure.update_camera = True
def find_fmri_files_min_max():
_addon().lock_colorbar_values()
abs_values = []
for constrast_name in fMRIPanel.clusters_labels_file_names:
constrast = {}
for hemi in mu.HEMIS:
contrast_fname = op.join(mu.get_user_fol(), 'fmri', 'fmri_{}_{}.npy'.format(constrast_name, hemi))
constrast[hemi] = np.load(contrast_fname)
clusters_labels_filtered = filter_clusters(constrast_name)
blobs_activity, _ = calc_blobs_activity(constrast, clusters_labels_filtered)
data_max, data_min = get_activity_max_min(blobs_activity)
abs_values.extend([abs(data_max), abs(data_min)])
data_max = max(abs_values)
_addon().set_colorbar_max_min(data_max, -data_max)
cm_name = _addon().get_colormap_name()
output_fname = op.join(mu.get_user_fol(), 'fmri', 'fmri_files_minmax_cm.pkl')
mu.save((data_min, data_max, cm_name), output_fname)
def save_graph_data(data, graph_colors, image_fol):
if not os.path.isdir(image_fol):
os.makedirs(image_fol)
mu.save((data, graph_colors), op.join(image_fol, 'data.pkl'))
print('Saving data into {}'.format(op.join(image_fol, 'data.pkl')))
def ray_cast():
context = bpy.context
scene = context.scene
layers_array = bpy.context.scene.layers
emptys_name = 'thickness_arrows'
show_hit = bpy.data.objects.get(emptys_name, None) is None
_addon().create_empty_if_doesnt_exists(emptys_name,
_addon().BRAIN_EMPTY_LAYER,
layers_array, 'Skull')
def draw_empty_arrow(vert_ind, loc, dir):
R = (-dir).to_track_quat('Z', 'X').to_matrix().to_4x4()
mt = bpy.data.objects.new('mt_{}'.format(vert_ind), None)
mt.name = 'mt_{}'.format(vert_ind)
R.translation = loc + dir
# mt.show_name = True
mt.matrix_world = R
mt.empty_draw_type = 'SINGLE_ARROW'
mt.empty_draw_size = dir.length
scene.objects.link(mt)
mt.parent = bpy.data.objects[emptys_name]
# check thickness by raycasting from inner object out.
# select inner and outer obj, make inner active
inner_obj = bpy.data.objects['inner_skull']
outer_obj = bpy.data.objects['outer_skull']
omwi = outer_obj.matrix_world.inverted()
output_fname = op.join(mu.get_user_fol(), 'skull', 'ray_casts.npy')
output_info_fname = op.join(mu.get_user_fol(), 'skull',
'ray_casts_info.pkl')
N = len(inner_obj.data.vertices)
vertices_thickness = np.zeros((N, 1))
thickness_info = {}
imw = inner_obj.matrix_world
omw = outer_obj.matrix_world
mat = omwi * imw
factor = np.linalg.inv(omw)[0, 0]
hits = [] # vectors from inner to outer
# for face in inner_obj.data.polygons:
for vert_ind, vert in enumerate(inner_obj.data.vertices):
# o = mat * face.center
# n = mat * (face.center + face.normal) - o
o = mat * vert.co
n = mat * (vert.co + vert.normal) - o
hit, loc, norm, index = outer_obj.ray_cast(o, n)
if hit:
print('{}/{} hit outer on face {}'.format(vert_ind, N, index))
hits.append((vert_ind, o, loc))
thickness = (omw * loc - omw * o).length * factor
else:
print('{}/{} no hit!'.format(vert_ind, N))
thickness = 0
vertices_thickness[vert_ind] = thickness
thickness_info[vert_ind] = (hit, np.array(loc), np.array(norm), index)
np.save(output_fname, vertices_thickness)
mu.save(thickness_info, output_info_fname)
if hits:
avge_thickness = sum((omw * hit - omw * o).length
for vert_ind, o, hit in hits) / len(hits)
print(avge_thickness)
if show_hit:
for vert_ind, hit, o in hits:
draw_empty_arrow(vert_ind, omw * o, omw * hit - omw * o)
def ray_cast(from_inner=True, create_thickness_arrows=None):
context = bpy.context
scene = context.scene
layers_array = bpy.context.scene.layers
from_string = 'from_{}'.format('inner' if from_inner else 'outer')
emptys_name = 'thickness_arrows_{}'.format(from_string)
if create_thickness_arrows is None:
create_thickness_arrows = bpy.context.scene.create_thickness_arrows
show_hit = bpy.data.objects.get(emptys_name,
None) is None and create_thickness_arrows
# check thickness by raycasting from inner object out.
# select inner and outer obj, make inner active
inner_obj = bpy.data.objects['inner_skull']
outer_obj = bpy.data.objects['outer_skull']
omwi = outer_obj.matrix_world.inverted(
) if from_inner else inner_obj.matrix_world.inverted()
output_fname = op.join(mu.get_user_fol(), 'skull',
'ray_casts_{}.npy'.format(from_string))
output_info_fname = op.join(mu.get_user_fol(), 'skull',
'ray_casts_info_{}.pkl'.format(from_string))
N = len(inner_obj.data.vertices) if from_inner else len(
outer_obj.data.vertices)
vertices_thickness = np.zeros((N, 1))
thickness_info = {}
imw = inner_obj.matrix_world if from_inner else outer_obj.matrix_world
omw = outer_obj.matrix_world if from_inner else inner_obj.matrix_world
mat = omwi * imw
factor = np.linalg.inv(omw)[0, 0]
ray_obj = outer_obj if from_inner else inner_obj
hits = []
vertices = inner_obj.data.vertices if from_inner else outer_obj.data.vertices
for vert_ind, vert in enumerate(vertices):
o = mat * vert.co
n = mat * (vert.co + vert.normal) - o
# if not from_inner:
# n *= -1
hit, loc, norm, index = ray_obj.ray_cast(o, n)
if hit:
# print('{}/{} hit {} on face {}'.format(vert_ind, N, 'outer' if from_inner else 'innner', index))
hits.append((vert_ind, o, loc))
thickness = (omw * loc - omw * o).length * factor
else:
print('{}/{} no hit!'.format(vert_ind, N))
thickness = 0
vertices_thickness[vert_ind] = thickness
thickness_info[vert_ind] = (hit, np.array(loc), np.array(norm), index)
np.save(output_fname, vertices_thickness)
mu.save(thickness_info, output_info_fname)
if hits:
avge_thickness = sum((omw * hit - omw * o).length
for vert_ind, o, hit in hits) / len(hits)
print(avge_thickness)
if show_hit:
_addon().create_empty_if_doesnt_exists(emptys_name,
_addon().BRAIN_EMPTY_LAYER,
layers_array, 'Skull')
for vert_ind, hit, o in hits:
draw_empty_arrow(scene, emptys_name, vert_ind, omw * o,
omw * hit - omw * o, from_inner)
def save_graph_data(data, graph_colors, image_fol):
if not os.path.isdir(image_fol):
os.makedirs(image_fol)
mu.save((data, graph_colors), op.join(image_fol, 'data.pkl'))
print('Saving data into {}'.format(op.join(image_fol, 'data.pkl')))
