예제 #1
0
def _load_bids(ctx, bids_dir):
    layout = BIDSLayout(bids_dir, absolute_paths=True)
    other_entities = ["datatype", "extension", "suffix"]

    # load

    anatfiles = layout.get(return_type="filename",
                           datatype="anat",
                           suffix="T1w")
    anat_pattern_set = _get_pattern_set(
        layout,
        anatfiles,
        ["subject"],
        other_entities,
        [],
    )
    _load_part(ctx, BIDSAnatTagsSchema(), anat_pattern_set)

    funcfiles = layout.get(return_type="filename",
                           datatype="func",
                           suffix="bold")
    func_pattern_set = _get_pattern_set(
        layout,
        funcfiles,
        ["subject", "session", "run", "task"],
        other_entities,
        ["RepetitionTime", "PhaseEncodingDirection", "EffectiveEchoSpacing"],
    )
    _load_part(ctx, BIDSBoldTagsSchema(), func_pattern_set)

    eventfiles = layout.get(return_type="filename",
                            datatype="func",
                            suffix="events",
                            extension="tsv")
    events_pattern_set = _get_pattern_set(
        layout,
        eventfiles,
        ["subject", "session", "run", "task"],
        other_entities,
        [],
    )
    _load_part(ctx, BIDSEventsTagsSchema(), events_pattern_set)

    fmap_pattern_set = _get_fmap_pattern_set(
        layout,
        funcfiles,
        ["subject", "session", "run", "task"],
        other_entities,
        ["PhaseEncodingDirection", "EchoTimeDifference", "EchoTime"],
    )
    _load_part(ctx, BIDSFmapTagsSchema(), fmap_pattern_set)

    participantsfilepath = op.join(bids_dir, "participants.tsv")
    if op.isfile(participantsfilepath):
        ctx.spreadsheet_file = participantsfilepath

    # validate

    funcfiles = ctx.database.get(
        datatype="func",
        suffix="bold")  # only validate files that made it to the database
    for funcfile in funcfiles:
        bidsfmapset = set()
        fmapslist = layout.get_fieldmap(funcfile, return_list=True)
        for fmaps in fmapslist:
            for fmapfile in fmaps.values():
                if not op.isfile(fmapfile):
                    continue
                bidsfmapset.add(fmapfile)
        fmapfiles = ctx.database.get_associations(funcfile, datatype="fmap")
        if fmapfiles is not None:
            specfmapset = set(fmapfiles)
            assert bidsfmapset == specfmapset, "Inconsistent FieldMap specification"
예제 #2
0
def main(sourcedata,
         derivatives,
         tmp_dir,
         subject=None,
         acquisition=None,
         session=None,
         run=None):

    if run is []:
        run = '[0-9]+'

    if subject in ['04', '01']:
        dof = 9
    else:
        dof = 6

    layout = BIDSLayout(sourcedata)
    derivatives_layout = BIDSLayout(derivatives)

    dtissue_left = get_derivative(derivatives,
                                  'nighres',
                                  'anat',
                                  subject,
                                  'dseg',
                                  hemi='left',
                                  space='average',
                                  description='cortex',
                                  session='anat')
    dtissue_right = get_derivative(derivatives,
                                   'nighres',
                                   'anat',
                                   subject,
                                   'dseg',
                                   hemi='right',
                                   space='average',
                                   description='cortex',
                                   session='anat')

    dura = get_dura_mask(derivatives, subject, 'average', 'anat')

    get_wm_wf = get_wm_seg_from_nighres(dtissue_left, dtissue_right)

    bold = []

    bold = layout.get(subject=subject,
                      session=session,
                      run=run,
                      acquisition=acquisition,
                      suffix='bold',
                      return_type='file')

    print(bold)

    epi = []
    for b in bold:
        fmaps = layout.get_fieldmap(b, return_list=True)
        for fmap in fmaps:
            if ('type' not in fmap) or (fmap['type'] == 'epi'):
                break
        epi.append(fmap['epi'])
        print('Using {} as epi_op for {}'.format(fmap['epi'], b))

    print(epi)

    t1w = get_derivative(derivatives,
                         'masked_mp2rages',
                         'anat',
                         subject,
                         'T1w',
                         session='anat',
                         space='average',
                         description='masked',
                         extension='nii.gz')

    print(t1w, os.path.exists(t1w))

    init_matrix = get_derivative(derivatives,
                                 'manual_transformations',
                                 'func',
                                 subject,
                                 'transform',
                                 session=session,
                                 space='average',
                                 extension='mat')

    os.environ['SUBJECTS_DIR'] = op.join(derivatives, 'freesurfer')

    wf = init_hires_unwarping_wf(
        name="unwarp_hires_{}_{}_{}".format(subject, session, acquisition),
        method='topup',
        bids_layout=layout,
        single_warpfield=False,
        register_to='last',
        init_transform=init_matrix,
        linear_registration_parameters='linear_hires.json',
        nonlinear_registration_parameters='nonlinear_precise.json',
        bold=bold,
        epi_op=epi,
        t1w_epi=None,
        t1w=t1w,
        dura_mask=dura,
        wm_seg=True,
        inv2_epi=None,
        dof=dof,
        crop_bolds=True,
        topup_package='afni',
        epi_to_t1_package='fsl',
        highpass_filter=True,
        within_epi_reg=True,
        freesurfer_subject_id='sub-{}'.format(subject),
        polish=True,
        num_threads_ants=4)

    wf.connect(get_wm_wf, 'outputspec.wm_seg', wf.get_node('inputspec'),
               'wm_seg')
    wf.base_dir = tmp_dir

    wf.run(plugin='MultiProc', plugin_args={'n_procs': 8})