def oxasl_preproc(wsp):
"""
Run standard processing on ASL data
This method requires wsp to be a Workspace containing certain standard information.
As a minimum, the attribute ``asldata`` must contain an AslImage object.
"""
if wsp.calib_first_vol and wsp.calib is None:
wsp.input.calib = wsp.asldata.calib
report_asl(wsp)
struc.init(wsp)
corrections.apply_corrections(wsp)
corrections.get_motion_correction(wsp)
corrections.apply_corrections(wsp)
reg.reg_asl2calib(wsp)
reg.reg_asl2struc(wsp, True, False)
reg.reg_asl2custom(wsp)
corrections.get_fieldmap_correction(wsp)
corrections.get_cblip_correction(wsp)
corrections.get_sensitivity_correction(wsp)
corrections.apply_corrections(wsp)
mask.generate_mask(wsp)
if oxasl_enable and wsp.use_enable:
wsp.sub("enable")
oxasl_enable.enable(wsp.enable)
wsp.corrected.asldata = wsp.enable.asldata_enable
def reg_asl2struc(wsp, flirt=True, bbr=False, name="initial"):
"""
Registration of ASL images to structural image
:param flirt: If provided, sets whether to use FLIRT registration
:param bbr: If provided, sets whether to use BBR registration
Required workspace attributes
-----------------------------
- ``regfrom`` : Registration reference image in ASL space
- ``struc`` : Structural image
Updated workspace attributes
----------------------------
- ``asl2struc`` : ASL->structural transformation matrix
- ``struc2asl`` : Structural->ASL transformation matrix
- ``regto`` : ``regfrom`` image transformed to structural space
"""
init(wsp)
struc.init(wsp)
if wsp.structural.struc is not None:
get_regfrom(wsp)
wsp.log.write("\nRegistering ASL data to structural data\n")
if flirt:
wsp.reg.regto, wsp.reg.asl2struc = reg_flirt(wsp, wsp.reg.regfrom, wsp.structural.brain, wsp.reg.asl2struc)
if bbr:
wsp.reg.regto, wsp.reg.asl2struc = reg_bbr(wsp)
wsp.reg.struc2asl = np.linalg.inv(wsp.reg.asl2struc)
wsp.log.write(" - ASL->Structural transform\n")
wsp.log.write(str(wsp.reg.asl2struc) + "\n")
wsp.log.write(" - Structural->ASL transform\n")
wsp.log.write(str(wsp.reg.struc2asl) + "\n")
page = wsp.report.page("asl2struc_%s" % name)
page.heading("%s ASL -> Structural registration" % name.title(), level=0)
page.heading("Transformation parameters", level=1)
motion_params = get_motion_params(wsp.reg.asl2struc)
page.table([
["Translation magnitude", "%.3g mm" % motion_params[0]],
["Rotation magnitude", "%.3g \N{DEGREE SIGN}" % motion_params[1]],
])
page.heading("ASL->Structural transformation matrix", level=1)
page.matrix(wsp.reg.asl2struc)
page.heading("Structural->ASL transformation matrix", level=1)
page.matrix(wsp.reg.struc2asl)
if wsp.structural.gm_seg is not None:
gm_asl = struc2asl(wsp, wsp.structural.gm_seg, interp="nn")
page.heading("GM mask aligned with ASL data", level=1)
page.image("gm_reg_%s" % name, LightboxImage(gm_asl, bgimage=wsp.reg.regfrom))
wm_asl = struc2asl(wsp, wsp.structural.wm_seg, interp="nn")
page.heading("WM mask aligned with ASL data", level=1)
page.image("wm_reg_%s" % name, LightboxImage(wm_asl, bgimage=wsp.reg.regfrom))
def main():
""" Simple test case """
from fsl.data.image import Image
from oxasl import Workspace
wsp = Workspace(savedir="epi_py_out", debug=True)
wsp.sub("reg")
wsp.regfrom = Image(sys.argv[1])
wsp.fslanat = sys.argv[2]
struc.init(wsp)
result = epi_reg(wsp, wsp.regfrom)
wsp.imgreg, wsp.img2struc = result["out.nii.gz"], result["out"]
def reg_struc2std(wsp, fnirt=False):
"""
Determine structural -> standard space registration
Optional workspace attributes
-----------------------------
- ``structural.struc`` : Structural image
- ``fslanat`` : Path to existing FSLANAT data
Updated workspace attributes
----------------------------
- ``reg.struc2std`` : Structural->MNI transformation matrix - either warp image or FLIRT matrix
- ``reg.std2struc`` : MNI->structural transformation - either warp image or FLIRT matrix
"""
init(wsp)
if wsp.reg.std2struc is not None:
return
if wsp.fslanat:
warp = os.path.join(wsp.fslanat, "T1_to_MNI_nonlin_coeff.nii.gz")
mat = os.path.join(wsp.fslanat, "T1_to_MNI_lin.mat")
if os.path.isfile(warp):
wsp.log.write(" - Using structural->std nonlinear transformation from FSL_ANAT\n")
wsp.reg.struc2std = Image(warp, loadData=False)
elif os.path.isfile(mat):
wsp.log.write(" - Using structural->std linear transformation from FSL_ANAT\n")
wsp.reg.struc2std = load_matrix(mat)
if wsp.reg.struc2std is None:
struc.init(wsp)
wsp.log.write(" - Registering structural image to standard space using FLIRT\n")
flirt_result = fsl.flirt(wsp.structural.brain, os.path.join(os.environ["FSLDIR"], "data/standard/MNI152_T1_2mm_brain"), omat=fsl.LOAD)
wsp.reg.struc2std = flirt_result["omat"]
if fnirt:
wsp.log.write(" - Registering structural image to standard space using FNIRT\n")
fnirt_result = fsl.fnirt(wsp.structural.brain, aff=wsp.reg.struc2std, config="T1_2_MNI152_2mm.cnf", cout=fsl.LOAD)
wsp.reg.struc2std = fnirt_result["cout"]
if isinstance(wsp.reg.struc2std, Image):
# Calculate the inverse warp using INVWARP
invwarp_result = fsl.invwarp(wsp.reg.struc2std, wsp.structural.struc, out=fsl.LOAD)
wsp.reg.std2struc = invwarp_result["out"]
else:
wsp.reg.std2struc = np.linalg.inv(wsp.reg.struc2std)
def get_rois(wsp):
"""
Generate ROIs for GM and noise
Existing ROIs may be provided. If provided in structural space, the ASL data is registered
to the structural image and the ROIS will be transformed to ASL space
If (either) of the noise or GM ROIs are not provided they are automatically generated as follows
- Grey matter: From segmentation of structural image (via FAST or FSL_ANAT output if provided)
- Noise: By inverting brain mask from brain-extracted structural image
A structural image is therefore required if either ROI needs to be generated, or if either ROI
is supplied in structural space.
Optional workspace attributes
-----------------------------
- ``regfrom`` : Reference image for registration of ASL to structural data
- ``asldata`` : Single TI ASL data. Middle volume will be used as reference if ``regfrom`` is required and not set
- ``gm_roi`` : Grey matter ROI in ASL or structural space
- ``noise_roi`` : Noise ROI in ASL or structural space
- ``noise_from_struc`` : If True, existing ``noise_roi`` image is in structural space
- ``gm_from_struc`` : If True, existing ``gm_roi`` image is in structural space
- ``struc`` : Structural image
Workspace attributes set
------------------------
- ``gm_roi`` : Grey matter ROI in ASL space
- ``noise_roi`` : Noise ROI in ASL space
"""
wsp.log.write("Generating ROIs...\n")
if wsp.regfrom is None:
wsp.log.write(" - Reference image for registration not provided - using ASL data middle volume\n")
middle = int(wsp.asldata.shape[3]/2)
wsp.regfrom = Image(wsp.asldata.data[:, :, :, middle], header=wsp.asldata.header)
struc.init(wsp)
if (wsp.gm_roi is None or wsp.noise_roi is None or wsp.noise_from_struc or wsp.gm_from_struc) and wsp.structural.struc is None:
raise RuntimeError("Need to specify a structural image unless you provide both noise and GM ROIs in ASL space")
if wsp.gm_roi is None:
struc.segment(wsp)
wsp.log.write("Taking GM ROI from segmentation of structural image\n")
wsp.gm_roi = Image((wsp.structural.gm_pv.data > 0).astype(np.int), header=wsp.structural.struc.header)
wsp.gm_from_struc = True
if wsp.noise_roi is None:
wsp.log.write("Generating noise ROI by inverting T1 brain mask\n")
wsp.noise_roi = Image(1-wsp.structural.brain_mask.data, header=wsp.structural.struc.header)
wsp.noise_from_struc = True
if wsp.noise_from_struc or wsp.gm_from_struc:
# Need struc->ASL registration space so we can apply to noise and/or GM ROIs
wsp.do_flirt = True
wsp.do_bbr = False
reg.reg_asl2struc(wsp)
if wsp.noise_from_struc:
wsp.log.write(" - Registering noise ROI to ASL space since it was defined in structural space\n\n")
wsp.noise_roi_struc = wsp.noise_roi
wsp.noise_roi = reg.struc2asl(wsp, wsp.noise_roi_struc, interp="nn")
if wsp.gm_from_struc:
wsp.log.write(" - Registering GM ROI to ASL space since it was defined in structural space\n\n")
wsp.gm_roi_struc = wsp.gm_roi
wsp.gm_roi = reg.struc2asl(wsp, wsp.gm_roi_struc, interp="nn")
wsp.log.write("DONE\n\n")
def generate_mask(wsp):
"""
Generate mask for ASL data
- If a ready-made mask image is provided or has already been generated, this is returned
- If a structural image is provided this will be used. Brain extraction and registration
will be performed if required
- If a calibration image is provided, this is used. It is assumed to be in the same space
as the ASL data
- If none of the above are present, the ASL data itself is averaged and brain extracted
to produce the mask
Required workspace attributes
-----------------------------
Formally there are no required attributes, however at least one image must be provided
which enables a mask to be generated.
Optional workspace attributes
-----------------------------
- ``asldata`` : ASL data image
- ``mask`` : Existing brain mask
- ``struc`` : Structural image (wholehead)
- ``struc_brain``: Already brain-extracted structural image
- ``asl2struc`` : Existring ASL->Structural space transformation matrix
- ``calib`` : Calibration image
- ``regfrom`` : ASL registration source image
"""
if wsp.rois is not None and wsp.rois.mask is not None:
return
wsp.sub("rois")
# Reporting
page = wsp.report.page("mask")
page.heading("Mask generation", level=0)
if wsp.mask is not None:
wsp.rois.mask_src = "user"
mask_source = "provided by user (assumed to be ASL space): %s" % wsp.mask.name
wsp.rois.mask = wsp.mask
elif wsp.structural.struc is not None:
# Preferred option is to use brain extracted structural
wsp.rois.mask_src = "struc"
struc.init(wsp)
page.heading("Brain extracted structural image", level=1)
page.image(
"struc_brain",
LightboxImage(wsp.structural.brain, bgimage=wsp.structural.struc))
brain_mask_asl = reg.struc2asl(wsp, wsp.structural.brain_mask)
wsp.rois.mask = Image(sp.ndimage.morphology.binary_fill_holes(
(brain_mask_asl.data > 0.25)).astype(np.int),
header=brain_mask_asl.header)
mask_source = "generated from brain extracting structural image and registering to ASL space"
else:
# Alternatively, use registration image (which will be BETed calibration or mean ASL image)
reg.get_regfrom(wsp)
wsp.rois.mask_src = "regfrom"
wsp.rois.mask = Image((wsp.reg.regfrom.data != 0).astype(np.int),
header=wsp.reg.regfrom.header)
mask_source = "generated from brain extracted registration ASL image"
wsp.log.write("\nGenerated ASL data mask\n")
wsp.log.write(" - Mask %s\n" % mask_source)
page.heading("Masked ASL brain image", level=1)
page.text("Mask was %s" % mask_source)
page.text("PW ASL image masked by ASL-space mask")
if wsp.asldata.iaf in ("diff", "tc", "ct"):
page.image(
"mask_outline",
LightboxImage(wsp.rois.mask,
bgimage=wsp.asldata.perf_weighted(),
outline=True))
else:
page.image(
"mask_outline",
LightboxImage(wsp.rois.mask,
bgimage=wsp.asldata.mean(),
outline=True))