def execution(self, context):
from soma import aims
graph = aims.read(self.read.fullPath())
aims.GraphManip.buckets2Volume(graph)
if self.extract_volume:
vol = graph[self.extract_volume]
else:
atts = [
x for x in graph.keys()
if isinstance(graph[x], aims.rc_ptr_Volume_S16)
]
if len(atts) == 0:
raise RuntimeError(_t_('the ROI graph contains no voxel data'))
elif len(atts) > 1:
raise RuntimeError(
_t_('the ROI graph contains several volumes. '
'Select the extract_volume parameter as one in ') + '( ' +
', '.join(atts) + ' )')
vol = graph[atts[0]]
# handle bounding box which may have cropped the data
bmin = graph['boundingbox_min']
bmax = graph['boundingbox_max']
context.write('vol:', vol)
context.write('bmin:', bmin, ', bmax:', bmax, ', size:', vol.getSize())
if bmin[:3] != [0, 0, 0] \
or bmax[:3] != [x+1 for x in vol.getSize()[:3]]:
context.write('enlarging')
# needs expanding in a bigger volume
vol2 = aims.Volume_S16(bmax[0] + 1, bmax[1] + 1, bmax[2] + 1)
vol2.fill(0)
ar = vol2.np
ar[bmin[0]:bmax[0] + 1, bmin[1]:bmax[1] + 1, bmin[2]:bmax[2] + 1, :] \
= vol.np
if self.extract_contours == 'Yes':
ar_copy = ar.copy()
for label in [v['roi_label'] for v in graph.vertices()]:
ind = list(zip(*np.where(ar_copy == label)))
for i in ind:
erase = True
for neigh in neighbors(*i):
if ar_copy[neigh] != label:
erase = False
if erase:
ar[i] = 0
vol2.copyHeaderFrom(vol.header())
aims.write(vol2, self.write.fullPath())
else:
# bounding box OK
aims.write(vol.get(), self.write.fullPath())
registration.getTransformationManager().copyReferential(
self.read, self.write)
if self.removeSource:
for f in self.read.fullPaths():
shelltools.rm(f)
def execution(self, context):
from soma import aims
r = aims.Reader({'Volume': {'S16': 'Graph'}})
graph = r.read(self.read.fullPath())
graph['filename_base'] = '*'
aims.GraphManip.volume2Buckets(graph)
aims.write(graph, self.write.fullPath())
registration.getTransformationManager().copyReferential(self.read,
self.write)
if self.removeSource:
for f in self.read.fullPaths():
shelltools.rm(f)
def execution(self, context):
#Load light objects first
csd = load(self.csd_model.fullPath())
dmri_vol = aims.read(self.diffusion_data.fullPath())
header = dmri_vol.header()
data = np.asarray(dmri_vol)
if self.mask is not None:
mask_vol = aims.read(self.mask.fullPath())
mask_arr = np.array(mask_vol, copy=True)
mask = mask_arr[..., 0]
if data.shape[:-1] != mask.shape:
raise ValueError(
'Diffusion data and mask used do not have the same shape')
else:
mask = self.mask
csdfit = csd.fit(data, mask=mask)
sh_coeff = csdfit.shm_coeff
sh_coeff_volume = array_to_vol(sh_coeff, header)
aims.write(sh_coeff_volume, self.fibre_odf_sh_coeff.fullPath())
transformManager = getTransformationManager()
transformManager.copyReferential(self.diffusion_data,
self.fibre_odf_sh_coeff)
pass
def execution(self, context):
tr = aims.AffineTransformation3d()
for t in self.MNI_transform_chain:
ti = aims.read(t.fullPath())
tr = ti * tr
#context.write('transform:', tr)
vol = aims.read(self.volume.fullPath())
trl = vol.header().get('transformations', [])
refl = vol.header().get('referentials', [])
rname = aims.StandardReferentials.mniTemplateReferential()
if rname in refl:
trl[refl.index(rname)] = tr.toVector()
elif len(trl) < 2:
#else:
trl.append(tr.toVector())
refl.append(rname)
else:
trl = [list(trl[0]), list(tr.toVector())] \
+ [list(t) for t in list(trl)[1:]]
refl = [refl[0], rname] + list(refl)[1:]
# context.write('now:', refl, trl)
vol.header()['referentials'] = refl
vol.header()['transformations'] = trl
context.write('new header:', vol.header())
aims.write(vol, self.output_volume.fullPath())
self.output_volume.readAndUpdateMinf()
tm = registration.getTransformationManager()
tm.copyReferential(self.volume,
self.output_volume,
copy_transformations=False)
def execution(self, context):
n_faces = 21
transformManager = getTransformationManager()
seeds_referential = transformManager.referential(self.seeds)
seeds_centers = np.loadtxt(self.seeds.fullPath())
n_sample = min(len(seeds_centers), self.n_sampling)
if len(seeds_centers) > self.n_display:
context.warning(
"You try to display more than ", str(self.n_display), " seeds. It may causes Memory Error. The first ", str(self.display)," seeds ONLY are displayed in order to prevent crashes")
radius = np.min(pdist(seeds_centers[:n_sample])) / 2.0
sphere = aims.SurfaceGenerator.icosphere((0, 0, 0), radius, n_faces)
vertices = np.array(sphere.vertex())
triangles = np.array(sphere.polygon())
seeds_centers = seeds_centers[:min(self.n_display, len(seeds_centers))]
new_vertices, new_triangles = quick_replicate_meshes(seeds_centers, vertices, triangles)
mesh = vertices_and_faces_to_mesh(new_vertices, new_triangles)
a = anatomist.Anatomist()
w3d = a.createWindow("3D")
A_graph = a.toAObject(mesh)
#yellow colors for the seeds (different form Red, Green , Blue so that they appears with orientation coded fibers
material = a.Material(diffuse=[1, 1, 0, 1])
A_graph.setMaterial(material)
A_graph.assignReferential(seeds_referential)
w3d.addObjects(A_graph)
return [w3d, A_graph]
def execution(self, context):
img = []
col = 0
for selfImg in self.images:
if col == 0:
imgcol = []
img.append(imgcol)
imgcol.append(selfImg)
col += 1
if col == len(self.colTitles):
col = 0
objs = displayTitledGrid(registration.getTransformationManager(),
None,
self.inverseRawColumn,
img,
rowTitles=self.rowTitles,
rowColors=self.rowColors,
colTitles=self.colTitles,
windowTitle=self.windowTitle,
linkWindows=self.linkWindows,
overlaidImages=self.overlaid_images,
mainColormap=self.mainColormap,
overlayColormap=self.overlayColormap,
customOverlayColormap=self.customOverlayColormap,
rowButtonSubTitles=self.rowButtonSubTitles)
return objs
def execution(self, context):
csd_model = load(self.csd_model.fullPath())
csd_coeff = aims.read(self.fibre_odf_sh_coeff.fullPath())
header = csd_coeff.header()
sh_coeff = np.asarray(csd_coeff)
mask_vol = aims.read(self.mask.fullPath())
mask = vol_to_array(mask_vol)
mask = array_to_mask(mask)
try:
S0 = aims.read(self.S0_signal.fullPath())
except:
context.write("No B0 volume provided, I assume the non ponderated signal value is 1.0 in all voxels")
S0 = 1
csd_fit = SphHarmFit(csd_model,sh_coeff, mask)
prediction = csd_fit.predict(gtab=None, S0=S0)
prediction_volume = array_to_vol(prediction, header)
aims.write(prediction_volume,self.predicted_signal.fullPath())
#Handling referentials
transformManager = getTransformationManager()
# Mandatory parameters
transformManager.copyReferential(self.fibre_odf_sh_coeff, self.predicted_signal)
pass
def execution(self, context):
#lazy load just to estimate the number of streamlines
tractogram, header = load_streamlines(self.streamlines.fullPath(),
lazy=False)
transformManager = getTransformationManager()
referential = transformManager.referential(self.streamlines)
#streamlines are in the LPI mm space
nb_streamlines = header['nb_streamlines']
streamlines = tractogram.streamlines
if nb_streamlines > self.max_number:
message = "The tractogram you try to display contains" + str(
nb_streamlines
) + "streamlines\n In order to avoid memory crash only the first " + self.max_number, " streamlines will be displayed"
"If your computer crashes consider decreasing self.max_number value \n. On the contrary if you have enough memory to display the whole tractogram you may want to increase self.max_number value"
context.write(message)
bundle = [s for i, s in enumerate(streamlines) if i < self.max_number]
else:
bundle = list(streamlines)
bundle_aims = bundle_to_mesh(bundle, encode_local=True)
del bundle
a = anatomist.Anatomist()
bundle_ana = a.toAObject(bundle_aims)
bundle_ana.setMaterial(use_shader=1, shader_color_normals=1)
bundle_ana.assignReferential(referential)
del bundle_aims
win = a.createWindow('3D')
win.addObjects(bundle_ana)
return [win, bundle_ana]
def execution(self, context):
context.write('Brain extraction using T1 mask')
mask_bin = context.temporary('gz compressed NIFTI-1 image')
cmd = [
'AimsThreshold', '-i', self.T1_to_b0_mask, '-o', mask_bin, '-m', 'gt',
'-t', '0', '-b', '--fg', '1'
]
context.system(*cmd)
cmd = [
'AimsMorphoMath', '-i', mask_bin, '-o', self.b0_brain_mask, '-r', '10',
'-m', 'clo'
]
context.system(*cmd)
cmd = [
'AimsMask', '-i', self.b0_volume, '-o', self.b0_brain, '-m',
self.b0_brain_mask
]
context.system(*cmd)
transformManager = getTransformationManager()
transformManager.copyReferential(self.b0_volume, self.b0_brain)
transformManager.copyReferential(self.b0_volume, self.b0_brain_mask)
context.write('Finished')
def search_transform(self, proc, dummy):
if self.volume is None:
return None
tm = registration.getTransformationManager()
pl = tm.findPaths(tm.referential(self.volume),
registration.talairachMNIReferentialId)
for p in pl:
return p
def linkRef(self, dummy):
if self.data is not None:
t = self.referential_type
if t == '':
t = None
return registration.getTransformationManager(
).findOrCreateReferential(diskItem=self.data,
referentialType=t,
simulation=True)
def execution(self, context):
self.read = None
if self.input_file:
self.read = self.input_file
elif self.input_directory:
self.read = self.input_directory
else:
context.error(
"You must give a valid value for input_file or input_directory.")
if self.read:
context.system(
'AimsFileConvert', '-i', self.read, '-o', self.write)
registration.getTransformationManager().copyReferential(self.read,
self.write)
if self.removeSource:
for f in self.read.fullPaths():
shelltools.rm(f)
def execution(self, context):
BrainExtraction.interactiveBrainExtraction(context,
self.b0_volume.fullPath(),
self.b0_brain.fullPath())
transformManager = getTransformationManager()
transformManager.copyReferential(self.b0_volume, self.b0_brain)
context.write('Finished')
def execution(self, context):
tex = aims.read(self.label_texture.fullPath())
mesh = aims.read(self.mesh.fullPath())
outmesh = aims.SurfaceManip.meshTextureBoundary(mesh, tex, -1)
diffuse = [1., 0, 0., 1.]
ncomp = min(len(self.mesh_color), 4)
diffuse[:ncomp] = self.mesh_color[:ncomp]
context.write(self.mesh_color)
outmesh.header()[ 'material' ] = \
{'line_width': self.line_width, 'diffuse': diffuse}
aims.write(outmesh, self.output_boundaries_mesh.fullPath())
tm = registration.getTransformationManager()
tm.copyReferential(self.mesh, self.output_boundaries_mesh)
def linkMNItransformation(proc, dummy):
if proc.source_volume:
tm = registration.getTransformationManager()
ref = tm.referential(registration.talairachMNIReferentialId)
if ref and tm.referential(proc.source_volume):
trans = tm.createNewTransformation('Transformation matrix',
proc.source_volume,
ref,
simulation=True)
return trans
else:
return WriteDiskItem(
'Transform Raw T1 MRI to Talairach-MNI template-SPM',
'Transformation Matrix').findValue(proc.source_volume)
def execution(self, context):
sourceUuid = self.image.uuid(saveMinf=False)
self.ROI.setMinf('source_volume', str(sourceUuid))
a = anatomist.Anatomist()
imageObject = a.loadObject(self.image)
nodesObjects = []
if not self.ROI.isReadable():
regionsObject = a.createGraph(object=imageObject,
name=self.ROI.fullPath(),
filename=self.ROI.fullPath())
# Create a region
nodesObjects.append(
regionsObject.createNode(name='region', duplicate=False))
else:
regionsObject = a.loadObject(self.ROI)
nodesObjects = regionsObject.children
# Show regions and linked image
block = a.createWindowsBlock()
windowC = a.createWindow('Coronal', block=block)
windowS = a.createWindow('Sagittal', block=block)
windowA = a.createWindow('Axial', block=block)
window3 = a.createWindow('3D', block=block)
# set the referential of the image to all the window and to the roi graph
ref = imageObject.referential
if ref != a.centralRef:
a.assignReferential(
ref, [windowC, windowS, windowA, window3, regionsObject])
a.addObjects([imageObject, regionsObject], [windowC, windowS, windowA])
a.setWindowsControl(windows=[windowC, windowS, windowA],
control="PaintControl")
window3.addObjects([regionsObject])
if nodesObjects: # the region must be selected to draw
a.getDefaultWindowsGroup().addToSelection(nodesObjects)
rep = context.ask("Click here when finished", "OK", "Cancel", modal=0)
if rep != 1:
regionsObject.save(self.ROI.fullPath())
a.sync()
# make sure that anatomist has finished to process previous
# commands
tm = registration.getTransformationManager()
tm.copyReferential(self.image, self.ROI)
def execution(self, context):
context.write('data:', self.data)
tm = registration.getTransformationManager()
ref = tm.referential(self.data)
context.write('existing referential:', ref)
# even if a referential exists, it can be incorrect, so use find or create
# referential
t = self.referential_type
if t == '':
t = None
ref = tm.findOrCreateReferential(diskItem=self.data,
referentialType=t,
assign=True,
output_diskitem=self.referential)
context.write('new ref:', ref)
def execution(self, context):
mesh = aims.read(self.white_mesh.fullPath())
vertices = np.array(mesh.vertex())
#extract texture
if self.roi_texture is None:
v = vertices
else:
texture = aims.read(self.roi_texture.fullPath())
tex = np.array(texture[0])
v = vertices[tex != 0]
np.savetxt(self.seeds.fullPath(), v)
transformManager = getTransformationManager()
transformManager.copyReferential(self.white_mesh, self.seeds)
def execution(self, context):
# Read header information
atts = aimsGlobals.aimsVolumeAttributes(self.volume_input)
ref = atts['referentials']
trf = atts['transformations']
if ("Scanner-based anatomical coordinates" in ref):
trm_to_scannerBased = trf[
ref.index("Scanner-based anatomical coordinates")]
# Create a referential for Scanner-based
tm = registration.getTransformationManager()
dest = tm.referential(self.new_referential)
context.write('dest:', dest)
if dest is None:
dest = tm.createNewReferentialFor(
self.new_referential, referentialType='Scanner Based Referential')
# Create a new referential if needed for the volume
# src = tm.referential( self.volume_input )
# print "Attributes"
# print self.volume_input.hierarchyAttributes()
# if src is None:
# print "create src"
# src = tm.createNewReferentialFor(self.volume_input)
# print "apres"
# print src
src = tm.referential(self.referential_volume_input)
context.write('src:', src)
# print "Attributes"
# print self.volume_input.hierarchyAttributes()
if src is None:
src = tm.createNewReferentialFor(self.volume_input,
referentialType='Referential of Raw T1 MRI',
output_diskitem=self.referential_volume_input)
dest.setMinf('direct_referential', 1, saveMinf=True)
# Store information into the trm file
mot = aims.Motion(trm_to_scannerBased)
aims.write(mot, self.T1_TO_Scanner_Based.fullPath())
# set and update database
tm.setNewTransformationInfo(
self.T1_TO_Scanner_Based, source_referential=src, destination_referential=dest)
def execution(self, context):
filetype = self.read.type
if filetype is getDiskItemType( 'SPM99 normalization matrix' ) \
or self.read.fullName()[-5:] == '_sn3d':
spm2 = 0
else:
spm2 = 1
AtoT = aims.readSpmNormalization(self.read.fullPath(),
self.source_volume.fullPath())
srcref = None
h = AtoT.header()
if 'source_referential' in h:
srcref = h['source_referential']
tm = registration.getTransformationManager()
if self.target != 'normalized_volume in AIMS orientation':
aims.write(AtoT, self.write.fullPath())
if self.target == 'MNI template':
destref = tm.referential(registration.talairachMNIReferentialId)
else:
destref = None
else: # normalized_volume in AIMS orientation
nim = self.normalized_volume
if not nim or not nim.isReadable():
raise RuntimeError(
_t_('normalized_volume shoud be specified when using this target mode'
))
context.write('use normalized image:', nim.fullPath(), '\n')
hasnorm = 1
attrs = shfjGlobals.aimsVolumeAttributes(nim)
t1 = aims.Motion(attrs['transformations'][-1])
AIMS = t1.inverse() * AtoT
AIMS.header().update(AtoT.header())
destref = tm.referential(nim)
aims.write(AIMS, self.write.fullPath())
if srcref or destref:
tm.setNewTransformationInfo(self.write, srcref, destref)
if self.removeSource:
for f in self.read.fullPaths():
os.unlink(f)
def execution(self, context): mask_vol = aims.read(self.mask.fullPath()) h = mask_vol.header() mask = np.asarray(mask_vol)[..., 0] mask = mask.astype(bool) voxel_size = np.array(h['voxel_size']) if len(voxel_size) == 4: voxel_size[-1] = 1 elif len(voxel_size) == 3: voxel_size = np.concatenate((voxel_size,np.ones(1))) scaling = np.diag(voxel_size) density = [self.nb_seeds_x, self.nb_seeds_y, self.nb_seeds_z ] seeds = seeds_from_mask(mask, density=density,affine=scaling) np.savetxt(self.seeds.fullPath(), seeds) transformManager = getTransformationManager() transformManager.copyReferential(self.mask, self.seeds)
def execution(self, context):
from soma import aims, aimsalgo
import numpy as np
vol = aims.read(self.image_input.fullPath())
old_t1_to_scanner = aims.AffineTransformation3d(
vol.header()['transformations'][0])
new_t1 = aims.read(self.target_space_image.fullPath())
new_t1_to_scanner = aims.AffineTransformation3d(
new_t1.header()['transformations'][0])
old_to_new = new_t1_to_scanner.inverse() * old_t1_to_scanner
rsp = getattr(aims, 'ResamplerFactory_' +
aims.typeCode(np.asarray(vol).dtype))().getResampler(0)
rsp.setRef(vol)
vol_resamp = rsp.doit(old_to_new, new_t1.getSizeX(), new_t1.getSizeY(),
new_t1.getSizeZ(),
new_t1.getVoxelSize()[:3])
aims.write(vol_resamp, self.image_output.fullPath())
tm = registration.getTransformationManager()
tm.copyReferential(self.target_space_image, self.image_output)
def execution(self, context):
context.write("Loading input files")
data_vol = aims.read(self.diffusion_data.fullPath())
hdr = data_vol.header()
data = vol_to_array(data_vol)
del data_vol
if self.mask is not None:
mask_vol = aims.read(self.mask.fullPath())
mask = vol_to_array(mask_vol)
del mask_vol
mask = array_to_mask(mask)
else:
mask = self.mask
tensor = load(self.tensor_model.fullPath())
context.write("Input files loaded successfully")
context.write(
"Fitting Diffusion Tensor model on data...it migh take some time")
tenfit = tensor.fit(data, mask=mask)
context.write("Diffusion Tensor Model fitted successfully")
tensor_coefficients = tenfit.model_params
vol_tensor = array_to_vol(tensor_coefficients, header=hdr)
context.write('Writing coefficient volume on disk')
aims.write(vol_tensor, self.tensor_coefficients.fullPath())
#saving other metadata
self.tensor_coefficients.setMinf('model_uuid', self.tensor_model.uuid())
self.tensor_coefficients.setMinf('data_uuid', self.diffusion_data.uuid())
try:
assert self.mask is not None
self.tensor_coefficients.setMinf('mask_uuid', self.mask.uuid())
except Exception:
self.tensor_coefficients.setMinf('mask_uuid', 'None')
transformManager = getTransformationManager()
transformManager.copyReferential(self.diffusion_data,
self.tensor_coefficients)
context.write("Processed Finished")
pass
def execution(self, context):
if not self.input.isWriteable():
raise RuntimeError(self.input.fullPath() + ' is not writeable')
tm = registration.getTransformationManager()
if self.normalization_template == 0:
ref = '49e6b349-b115-211a-c8b9-20d0ece9846d'
trans = tm.findPaths(ref, registration.talairachMNIReferentialId)
tm.setReferentialTo(self.input, ref)
self.fixtransformation(trans, context)
elif self.normalization_template == 1:
ref = '19bfee8e-51b1-4d9e-8721-990b9f88b12f'
trans = tm.findPaths(ref, registration.talairachMNIReferentialId)
tm.setReferentialTo(self.input, ref)
self.fixtransformation(trans, context)
elif self.normalization_template == 2:
ref = 'f3848046-b581-cae4-ecb9-d80ada0278d5'
trans = tm.findPaths(ref, registration.talairachMNIReferentialId)
tm.setReferentialTo(self.input, ref)
self.fixtransformation(trans, context)
else:
pass # TODO
def execution(self, context):
csd_model = load(self.csd_model.fullPath())
csd_coeff = aims.read(self.fibre_odf_sh_coeff.fullPath())
h = csd_coeff.header()
sh_coeff = np.asarray(csd_coeff)
mask_vol = aims.read(self.mask.fullPath())
mask = np.array(mask_vol,copy=False)[...,0].copy()
context.write(mask.shape)
csd_fit = SphHarmFit(csd_model,sh_coeff, mask)
transformManager = getTransformationManager()
# Mandatory parameters
gfa = csd_fit.gfa
GFA = self.array_to_vol(gfa,h)
aims.write(GFA, self.generalized_fractionnal_anisotropy.fullPath())
transformManager.copyReferential(self.fibre_odf_sh_coeff, self.generalized_fractionnal_anisotropy)
pass
def execution(self, context):
tensor_coeff = aims.read(self.tensor_coefficients.fullPath())
tensor_params = np.asarray(tensor_coeff)
tensor_model = load(self.tensor_model.fullPath())
gtab = tensor_model.gtab
#Loading base signal
S0 = aims.read(self.S0_signal.fullPath())
S0 = vol_to_array(S0)
tenfit = TensorFit(tensor_model, tensor_params)
pred_sign = tenfit.predict(gtab=gtab, S0=S0)
hdr = tensor_coeff.header()
pred_vol = array_to_vol(pred_sign, header=hdr)
aims.write(pred_vol, self.predicted_signal.fullPath())
#Handling metada
transformManager = getTransformationManager()
transformManager.copyReferential(self.predicted_signal,
self.tensor_coefficients)
context.write("Process finish successfully")
pass
def execution(self, context):
context.write(
'Susceptibility induced distortion correction using Fieldmap... [~1mn]'
)
context.write('- Identification of first b0 volume')
img = aims.read(self.dwi_data.fullPath())
dwi_data = img.arraydata()
bvals = numpy.loadtxt(self.bvals.fullPath())
b0_index = numpy.where(bvals < 100)[
0] ## bvals==0 not possible when bvalues take values +-5 or +-10
b0 = dwi_data[b0_index[0], :, :, :]
b0_vol = aims.Volume(b0)
b0_vol.copyHeaderFrom(img.header())
b0_tmp = context.temporary('NIFTI-1 image')
aims.write(b0_vol, b0_tmp.fullPath())
configuration = Application().configuration
FSL_directory = os.path.dirname(self.fieldmap_brain.fullPath())
PE_list = ["AP", "PA", "LR", "RL"]
dir_list = ["y-", "y", "x-", "x"]
warping_direction = dir_list[PE_list.index(self.phase_encoding_direction)]
context.write('- Brain extraction of magnitude image')
BrainExtraction.defaultBrainExtraction(self.magnitude.fullPath(),
self.magnitude_brain.fullPath(),
f=str(self.brain_extraction_factor))
# cmd = [ configuration.FSL.fsl_commands_prefix + 'fslmaths', self.fieldmap.fullPath(), '-mas', self.magnitude_brain.fullPath(), self.fieldmap_brain.fullPath() ]
# context.system( *cmd )
# unmask the fieldmap (necessary to avoid edge effects)
cmd = [
configuration.FSL.fsl_commands_prefix + 'fslmaths',
self.magnitude_brain.fullPath(), '-bin',
self.magnitude_brain_mask.fullPath()
] #
context.system(*cmd) #
cmd = [
configuration.FSL.fsl_commands_prefix + 'fugue',
'--loadfmap=' + self.fieldmap.fullPath(),
'--mask=' + self.magnitude_brain_mask.fullPath(), '--unmaskfmap',
'--savefmap=' + self.fieldmap_brain.fullPath(),
'--unwarpdir=' + warping_direction
] #
context.system(*cmd) #
context.write('- Fieldmap smoothing')
cmd = [
configuration.FSL.fsl_commands_prefix + 'fugue',
'--loadfmap=' + self.fieldmap_brain.fullPath(), '--despike',
'--smooth3=' + str(self.fieldmap_smoothing),
'--savefmap=' + self.fieldmap_brain.fullPath()
]
context.system(*cmd)
context.write('- Magnitude image warping using fieldmap')
cmd = [
configuration.FSL.fsl_commands_prefix + 'fugue', '-v', '-i',
self.magnitude_brain.fullPath(), '--dwell=' + str(self.echo_spacing),
'--unwarpdir=' + warping_direction,
'--loadfmap=' + self.fieldmap_brain.fullPath(), '-w',
self.magnitude_warped.fullPath()
]
context.system(*cmd)
context.write('- Registration of fieldmap into diffusion space')
cmd1 = [
configuration.FSL.fsl_commands_prefix + 'flirt', '-dof', '12', '-in',
self.magnitude_warped.fullPath(), '-ref',
b0_tmp.fullPath(), '-out',
self.magnitude_warped_to_dwi.fullPath(), '-omat',
self.fieldmap_to_dwi_mat.fullPath()
]
cmd2 = [
configuration.FSL.fsl_commands_prefix + 'flirt', '-dof', '12', '-in',
self.fieldmap_brain.fullPath(), '-ref',
b0_tmp.fullPath(), '-applyxfm', '-init',
self.fieldmap_to_dwi_mat.fullPath(), '-out',
self.fieldmap_to_dwi.fullPath()
]
context.system(*cmd1)
context.system(*cmd2)
transformManager = getTransformationManager()
transformManager.copyReferential(self.dwi_data,
self.magnitude_warped_to_dwi)
transformManager.copyReferential(self.dwi_data, self.fieldmap_to_dwi)
context.write('- Unwarping of dwi image using fieldmap')
cmd = [
configuration.FSL.fsl_commands_prefix + 'fugue', '-v', '-i',
self.dwi_data.fullPath(), '--dwell=' + str(self.echo_spacing),
'--unwarpdir=' + warping_direction,
'--loadfmap=' + self.fieldmap_to_dwi.fullPath(), '-u',
self.dwi_unwarped.fullPath(), '--icorr',
'--saveshift=' + FSL_directory + '/pixel_shift.nii.gz'
] #'--mask=' + self.magnitude_warped_to_dwi_brain_mask.fullPath(), '--smooth3=' + str(self.fieldmap_smoothing),
context.system(*cmd)
cmd = [
configuration.FSL.fsl_commands_prefix + 'fslmaths',
self.dwi_unwarped.fullPath(), '-abs',
self.dwi_unwarped.fullPath()
]
context.system(*cmd)
transformManager.copyReferential(self.dwi_data, self.dwi_unwarped)
context.write('Finished')
def execution(self, context):
configuration = Application().configuration
tmp_file = context.temporary('File')
tmp_deform = context.temporary('File')
#if self.registration_method == 'niftyreg':
# new niftyreg deformation volume is X,Y,Z,1,3 instead of X,Y,Z,3
deform_vol = nib.load(self.diff_to_T1_nonlinear_dfm.fullPath())
if len(deform_vol.shape) == 5:
deform = deform_vol.get_data()
deform = deform[..., 0, :]
nib.save(nib.Nifti1Image(deform, deform_vol.affine),
tmp_deform.fullPath() + '.nii.gz')
else:
nib.save(deform_vol, tmp_deform.fullPath() + '.nii.gz')
#reuse Lucile code to split volume cause dont want to mess with orientations as it worked
cmd = [
configuration.FSL.fsl_commands_prefix + 'fslsplit',
tmp_deform.fullPath() + '.nii.gz',
tmp_file.fullPath(), '-t'
]
context.system(*cmd)
context.write(tmp_file.fullPath())
f1 = aims.read(tmp_file.fullPath() + '0000.nii.gz')
f2 = aims.read(tmp_file.fullPath() + '0001.nii.gz')
f3 = aims.read(tmp_file.fullPath() + '0002.nii.gz')
f = np.concatenate((f1.arraydata(), f2.arraydata(), f3.arraydata()))
field = np.swapaxes(f, 0, 3)
field = np.swapaxes(field, 1, 2)
vxsize = np.array(f1.header()['voxel_size'][:3])
affine = f1.header()['transformations']
affine_mm = np.reshape(affine[0], (4, 4))
mesh = aims.read(self.WM_mesh_in_T1.fullPath())
new_mesh = meshTransform(mesh, field, vxsize, affine_mm)
aims.write(new_mesh, self.WM_mesh_in_DWI.fullPath())
cmd = [
'AimsMeshTransform', '-i', self.WM_mesh_in_DWI, '-t',
self.T1_to_diff_linear_xfm, '-o', self.WM_mesh_in_DWI
]
context.system(*cmd)
transformManager = getTransformationManager()
transformManager.copyReferential(self.b0_volume, self.WM_mesh_in_DWI)
mesh = aims.read(self.GM_mesh_in_T1.fullPath())
new_mesh = meshTransform(mesh, field, vxsize, affine_mm)
aims.write(new_mesh, self.GM_mesh_in_DWI.fullPath())
cmd = [
'AimsMeshTransform', '-i', self.GM_mesh_in_DWI, '-t',
self.T1_to_diff_linear_xfm, '-o', self.GM_mesh_in_DWI
]
context.system(*cmd)
transformManager = getTransformationManager()
transformManager.copyReferential(self.b0_volume, self.GM_mesh_in_DWI)
# elif self.registration_method == 'fnirt':
# field_file = context.temporary('gz compressed NIFTI-1 image')
# # cmd = [configuration.FSL.fsl_commands_prefix + 'fnirtfileutils', '-i', self.diff_to_T1_nonlinear_dfm.fullPath(), '-r', self.T1_volume.fullPath(), '-o', field_file.fullPath()]
# # context.system(*cmd)
# cmd = [configuration.FSL.fsl_commands_prefix + 'fslsplit', self.diff_to_T1_nonlinear_dfm.fullPath(), tmp_file.fullPath(), '-t']
# context.system(*cmd)
# f1 = aims.read(tmp_file.fullPath() + '0000.nii.gz')
# f2 = aims.read(tmp_file.fullPath() + '0001.nii.gz')
# f3 = aims.read(tmp_file.fullPath() + '0002.nii.gz')
# f = np.concatenate((f1.arraydata(), f2.arraydata(), f3.arraydata()))
# field = np.swapaxes(f, 0, 3)
# field = np.swapaxes(field, 1, 2)
# t1 = aims.read(self.T1_volume.fullPath())
# vxsize = np.array(f1.header()['voxel_size'][:3])
# affine = t1.header()['transformations']
# # affine = f1.header()['transformations']
# affine_mm = np.reshape(affine[0], (4, 4))
#
# mesh = aims.read(self.WM_mesh_in_T1.fullPath())
# new_mesh = meshTransform(mesh, field, vxsize, affine_mm)
# aims.write(new_mesh, self.WM_mesh_in_DWI.fullPath())
# transformManager = getTransformationManager()
# transformManager.copyReferential(self.b0_volume, self.WM_mesh_in_DWI)
#
# mesh = aims.read(self.GM_mesh_in_T1.fullPath())
# new_mesh = meshTransform(mesh, field, vxsize, affine_mm)
# aims.write(new_mesh, self.GM_mesh_in_DWI.fullPath())
# transformManager = getTransformationManager()
# transformManager.copyReferential(self.b0_volume, self.GM_mesh_in_DWI)
context.write('Finished')
def execution(self, context):
tensor_coeff_vol = aims.read(self.tensor_coefficients.fullPath())
tensor_coeff = np.asarray(tensor_coeff_vol)
hdr = tensor_coeff_vol.header()
tensor_model = load(self.tensor_model.fullPath())
tenfit = TensorFit(tensor_model, tensor_coeff)
#Mandatory parameters
fa = tenfit.fa
FA = array_to_vol(fa, hdr)
aims.write(FA, self.fractionnal_anisotropy.fullPath())
md = tenfit.md
MD = array_to_vol(md, hdr)
aims.write(MD, self.mean_diffusivity.fullPath())
evecs = tenfit.evecs
vectors = [
evecs[:, :, :, :, 0], evecs[:, :, :, :, 1], evecs[:, :, :, :, 2]
]
evals = tenfit.evals
eigen_values = array_to_vol(evals, hdr)
aims.write(eigen_values, self.evals.fullPath())
vectors_volume = [array_to_vol(v, hdr) for v in vectors]
aims.write(vectors_volume[0], self.first_eigen_vector.fullPath())
aims.write(vectors_volume[1], self.second_eigen_vector.fullPath())
aims.write(vectors_volume[2], self.third_eigen_vector.fullPath())
color_fa = tenfit.color_fa
color_fa_vol = array_to_vol(color_fa)
aims.write(color_fa_vol, self.colored_fractionnal_anisotropy.fullPath())
# handling referentials
transformManager = getTransformationManager()
transformManager.copyReferential(self.tensor_coefficients,
self.fractionnal_anisotropy)
transformManager.copyReferential(self.tensor_coefficients,
self.mean_diffusivity)
# additionnal metadata
self.mean_diffusivity.setMinf('tensor_coefficients_uuid',
self.tensor_coefficients.uuid())
self.fractionnal_anisotropy.setMinf('tensor_coefficients_uuid',
self.tensor_coefficients.uuid())
if self.advanced_indices:
axial_diffusivity = tenfit.ad
planarity = tenfit.planarity
sphericity = tenfit.sphericity
linearity = tenfit.linearity
mode = tenfit.mode
disk_items = [
self.axial_diffusivity, self.planarity, self.sphericity,
self.linearity, self.mode
]
arrays = [axial_diffusivity, planarity, sphericity, linearity, mode]
for ind, a in enumerate(arrays):
vol = array_to_vol(a, hdr)
aims.write(vol, disk_items[ind].fullPath())
transformManager.copyReferential(self.tensor_coefficients,
disk_items[ind])
pass
def execution(self, context):
configuration = Application().configuration
transformManager = getTransformationManager()
niftyreg_resample = find_executable('reg_resample')
#no longer needed since validation check !
#if not niftyreg_resample:
#raise RuntimeError(_t_('Niftyreg executable NOT found !'))
reg = context.temporary('File')
tmp_file = context.temporary('gz compressed NIFTI-1 image')
cmd = [
configuration.FSL.fsl_commands_prefix + 'fslmaths',
self.ROI_in_T1.fullPath()
]
if self.lower_thresh is not None:
cmd += ['-thr', self.lower_thresh]
if self.upper_thresh is not None:
cmd += ['-uthr', self.upper_thresh]
cmd += ['-bin', tmp_file.fullPath()]
context.system(*cmd)
## A SUPPRIMER EN DEHORS DU HCP : A CAUSE ORIENTATION RAS A POSTERIORI
# tmp_b0 = context.temporary('gz compressed NIFTI-1 image')
# os.system(' '.join(['AimsFileConvert', '-i', self.b0_volume.fullPath(), '-o', tmp_b0.fullPath(), '--orient', '"abs: 1 -1 -1"']))
##
if self.T1_to_b0_registration_method == 'niftyreg':
cmd = [
niftyreg_resample, '-ref',
self.T1_volume.fullPath(), '-flo',
tmp_file.fullPath(), '-trans',
self.T1_to_diff_nonlinear_dfm.fullPath(), '-res',
reg.fullPath() + '_ROI.nii.gz', '-inter', '0'
]
context.system(*cmd)
cmd = [
'AimsResample', '-i',
reg.fullPath() + '_ROI.nii.gz', '-m', self.T1_to_diff_linear_xfm,
'-t', '0', '-o', self.ROI_in_DWI, '-d', '1', '-r',
self.b0_volume.fullPath()
]
context.system(*cmd)
elif self.T1_to_b0_registration_method == 'fnirt':
cmd = [
configuration.FSL.fsl_commands_prefix + 'applywarp', '-i',
tmp_file.fullPath(), '-r',
self.b0_volume.fullPath(), '-o',
self.ROI_in_DWI.fullPath(), '-w',
self.T1_to_diff_nonlinear_dfm.fullPath(), '--interp=nn'
]
context.system(*cmd)
if self.binarise:
cmd = [
configuration.FSL.fsl_commands_prefix + 'fslmaths',
self.ROI_in_DWI.fullPath(), '-thr', self.threshold, '-bin',
self.ROI_in_DWI.fullPath()
] # , '--fg', '1']
else:
cmd = [
configuration.FSL.fsl_commands_prefix + 'fslmaths',
self.ROI_in_DWI.fullPath(), '-thr', self.threshold,
self.ROI_in_DWI.fullPath()
] # , '--fg', '1']
context.system(*cmd)
# ref = self.b0_volume.get('storage_to_memory', search_header=True)
# transformManager.copyReferential(self.b0_volume, self.ROI_in_DWI)
## A SUPPRIMER EN DEHORS DU HCP : A CAUSE ORIENTATION RAS A POSTERIORI
# os.system(' '.join(['AimsFileConvert', '-i', self.ROI_in_DWI.fullPath(), '-o', self.ROI_in_DWI.fullPath(), '--orient', '"abs: -1 -1 -1"']))
##
context.write('Finished')
