AFNI notes

Doing visual localizers in freesurfer/afni+suma

AFNI glossary

• sub-brick: each 3D array in a dataset
• .HEAD is the header file
• .BRIK is the file with all the sub-bricks
• Coordinate systems:
  • +orig: scanner coordinates
  • +acpc: ACPC aligned
  • +tlrc: talairach
• Session: a directory with all the data from that session—assumed to have same view and same coordinates
• AVol: anatomy volume
  • AVol@Epi: the anatomy volume registered to the EPI data
• SVol: surface volume
  • SVol@Epi: the surface volume registered to the EPI data

AFNI programs/scripts

• to3d: converts dicom or nifti data into AFNI bricks; called with only input file (to3d myfile) brings up a gui which can preview the data
  • to3d –prefix outFileStub inputFile.ext
  • to3d inputFile [launches gui]
• 3dvolreg: motion correction on functional data (within scan and between scans)
• 3dWarpDrive: warp??
• 3dcalc: average functional data
  • Binary Mask: 3dcalc –prefix OutFile.type –a FileToMaskOn –expr ‘step(a)’
• Afni_proc.py: single subject FMRI preproc and TS analysis for functional activation
• Uber_subject.py: GUI for afni_proc.py
• Align_epi_anat.py: image alignment (registration): anatomical—EPI, anatomical—anatomical, EPI—EPI, and to atlas space (talairach/MNI)
  • use this instead of 3dvolreg and 3dWarpDrive
  • need to AlignCenters first!!!
  • Partial_coverge flag
• 3dAFNItoNIFTI: converts brik/head files to nifti
• Afni –niml: run afni with comms port open
• Suma –spec ../path/to/specFile.spec –sv LocalFileSVol@Epi+orig

For each subject, process the anatomy (one time only) in freesurfer

1. recon-all
2. check the output, edit WM (etc) as necessary, rerun steps if needed
3. cut patches and flatten them
   1. tksurfer to cut patches
   2. mris_flatten to flatten the patches
4. port the various anatomy files to AFNI
   1. @SUMA_Make_Spec_FS

Process the functional data

• Traveling wave (rotating wedges and expanding/contracting rings) can be done with the @RetinoProc command; object and motion scans can be processed as traditional block design studies
• This step could also be done with custom code (e.g., python or matlab script to do the traveling wave analysis). In the end we need a nifti file with the parameters (e.g., phase and coherence threshold)

1. Wedges and rings
   1. Setup a script to call @RetinoProc (which calls 3dRetinoPhase), which needs
      1. SUMA’d brain (from @SUMA_Make_Spec step)
      2. Lh and rh spec files (from @SUMA_Make_Spec)
      3. (original?) anatomy volume as a single .nii file (T1 intcorr???)
      4. Details on the functional data
         1. Tr—note that AFNI read Tr differently and often need a 3drefit command to tell it Tr is in s vs ms
         2. Period and # of blocks
         3. # and size of rings/wedges
         4. which scan was which
         5. time before stim starts
         6. # volumes to ignore (e.g., reference volumes)
      5. Run the script that calls @RetinoProc. My example is a modified @Proc.All
   2. Outputs are put into a new folder called ProcOut.All
   3. View them via:
      1. afni –niml & (launches afni with niml comms enabled and runs in the background)
      2. suma –spec ../SUMA/s1032_lh.spec –sv SVol@Epi+orig (spec file is the original freesurfered spec for one/both hemispheres—could copy over or leave in orig directory. Surface volume file is the aligned SVol, which is in the results directory, NOT the original s1032_SurfVol+orig file. SVol file MUST be in the same directory as results)
      3. in AFNI
         1. load the SVol@Epi+orig as underlay (must do this before enabling comms within suma)
      4. In SUMA
         1. View…surface controller…Load Dset then choose the lh.pol.field (or rh…)
         2. Also interesting to load ecc.field, then can switch between the two
         3. Use . and , to cycle between surfaces (inflated/patches/flats)
         4. Hit t to link to AFNI
      5. To be able to see the output in AFNI, the niml.dset files have to be converted to AFNI format using
         1. ConvertDset .,….. didn’t work don’t really need this.
   4. What’s inside the polar angle dataset. 3 columns (for each node)
      1. Polar angle (0 to 360)... relative to starting angle (wherever your stimulus was when you started, counting from the first non-ignored volume)
      2. Hemo. Offset (-180 to 178.9076)
      3. Max.PwR@0.042Hz (0 to 2606.652)—use this for thresholding which voxels to display!
   5. Load custom colormap to match Larsson and Heeger—near cmap click new.
      1. Format of colormap file—space delimited text file with r g b values, one set per row, # of rows = # colors, file name: MyColorMap.1D.cmap
   6. The polar angle that SUMA displays is (I think) the angle relative to the starting angle of the stimulus. It doesn’t know what angle I started my wedge at (or eccentricity I started the ring at), so it’s just giving relative place in the cycle.
   7. e. How do I perform distortion compensation? Fsl on the command line, but when (which stage) and on what file? Presumably right after moco, but how can I do that when it’s all wrapped up in RetinoProc?
      1. The script automatically does motion compensation (“registration”) in the AFNI way of aligning the anatomy TO the EPI reference and the remaining EPI volumes to that EPI reference. The surface (from freesurfer) is then aligned to the post-alignment anatomy volume.
      2. One can bypass this automatic alignment step by specifying a couple of flags in the call to RetinoProc—pass in the pre-aligned volumes
         1. Do the distCo and moCo beforehand then give those results to RetinoProc.
         2. Use align_epi_anat.py (or 3dAllineate)????
2. Motion and object scans are processed as a block design
   1. Convert DCM to afni files with to3d, then move the output to the “session” dir
   2. Use uber_subject.py to setup the AFNI session (GUI for afni_proc.py which is the single subject preprocessing and timeseries analysis)
      1. Location of anatomy files
      2. Location of EPI files
      3. Location of text file with timing information (block design specs)
         1. Text file with time onset of each stim—one file for each stim type
         2. Within one file, one ROW for each SCAN—times are relative to start of TRIMMED scan
            1. E.g., throw away first 6 Trs (2 sec each). The stim literally starts 12 sec into the run, but the first time I’d specify in stimtiming is 0s, since it starts 0s after the start of the trimmed file
         3. When using uber_subject.py, the stim file is a bit tricky. If there is only ONE condition (as in motion or object, where it’s the one thing or “nothing”), uber_subject.py has an error—have to explicitly type in the label, and do this BEFORE clicking on the block(x,y) which resets the labels.
            1. Or……have to redo the label after the block thing, which overwrote the label
         4. Time in seconds, not Trs,
         5. stimName.1D as filename
      4. # of points to remove from each EPI
      5. “blur” size
   3. Prepare to view results on the surface by aligning the surfaces to the EPI data
      1. Change directory to the folder containing the results of the block analysis
      2. @SUMA_AlignToExperiment –exp_anat ExpVol+orig –surf_anat /path/to/surfaces/SurfVol+orig
      3. Copy the SVol@Epi+orig file over to the output directory
   4. Load up in AFNI alone (from output dir)
      1. afni &
      2. Choose anat_final for underlay
      3. Choose stats as overlay—Olay is coeff, Thr is Tstat, ** to 1, # to 12
   5. Load up AFNI and SUMA (from output dir)
      1. afni –niml &
      2. suma –spec ../SUMA/s1032_lh.spec –sv SVol@Epi+orig

Distortion compensation

1. strip skull of field map magnitude (via bet, or afni, or manually)
   1. bet magFile magStripped -m
   2. (here, magFile was MR-ST001-SE013-0001.dcm)
2. scale phase map to 0-2pi via fslmaths
   1. fslmaths phaseFile -sub 2048 -mul 3.14159 -div 2048 ph_rad -odt float
   2. (here phaseFile was MR-ST001-SE013-EC2-0001.dcm)
3. unwrap the phasemap using stripped brain as mask, via prelude
   1. prelude -p ph_rad -a magStripped -m magStripped_mask -o ph_rad_unwrapped
4. convert to freq map (rad/ms) via fslmaths
   1. fslmaths ph_rad_unwrapped -div 1.02 ph_rad_per_ms
   2. (here, 1.02 is the delta TE of the field map)
5. apply field map to data via fugue
   1. fugue -i epiFile --loadfmap=ph_rad_per_ms --dwell=.105 --unwarpdir=y -u epi_unwarped
   2. (here dwell time is EPI echo spacing divided by acceleration factor, 0.42/4)
   3. (here unwarpdir was positive y, gained by trial and error!)