def _run_interface(self, runtime):
# Load the zstat data
z_img = nib.load(self.inputs.zstat_file)
z_data = z_img.get_data()
# Load the peaks
peaks_df = pd.read_table(self.inputs.localmax_file, "\t")
peaks = peaks_df[["x", "y", "z"]].values
# Possibly do the segmentation, if there are peaks
if len(peaks):
seg, markers = self.segment(z_data, peaks)
else:
seg, markers = np.zeros_like(z_data), np.zeros_like(z_data)
# Set up the output names
seg_fname = op.basename(add_suffix(self.inputs.zstat_file, "seg"))
peak_fname = op.basename(add_suffix(self.inputs.zstat_file, "peaks"))
lut_fname = seg_fname.replace(".nii.gz", ".txt")
self._seg_fname = seg_fname
self._peak_fname = peak_fname
self._lut_fname = lut_fname
# Write the output images
self.write_output(seg, seg_fname)
self.write_output(markers, peak_fname)
# Create a LUT and save it
lut_data = self.create_lut(markers)
lut_data.to_csv(lut_fname, "\t", index=False)
return runtime
def _run_interface(self, runtime):
# Load the zstat data
z_img = nib.load(self.inputs.zstat_file)
z_data = z_img.get_data()
# Load the peaks
peaks_df = pd.read_table(self.inputs.localmax_file, "\t")
peaks = peaks_df[["x", "y", "z"]].values
# Possibly do the segmentation, if there are peaks
if len(peaks):
seg, markers = self.segment(z_data, peaks)
else:
seg, markers = np.zeros_like(z_data), np.zeros_like(z_data)
# Set up the output names
seg_fname = op.basename(add_suffix(self.inputs.zstat_file, "seg"))
peak_fname = op.basename(add_suffix(self.inputs.zstat_file, "peaks"))
lut_fname = seg_fname.replace(".nii.gz", ".txt")
self._seg_fname = seg_fname
self._peak_fname = peak_fname
self._lut_fname = lut_fname
# Write the output images
self.write_output(seg, seg_fname)
self.write_output(markers, peak_fname)
# Create a LUT and save it
lut_data = self.create_lut(markers)
lut_data.to_csv(lut_fname, "\t", index=False)
return runtime
def _run_interface(self, runtime):
n_runs = len(self.inputs.rigids)
if isdefined(self.inputs.first_rigid):
first_rigid = self.inputs.first_rigid
else:
first_rigid = self.inputs.rigids[0]
out_files = []
for i in range(n_runs):
# Set up the output directory
out_dir = "run_{}/".format(i + 1)
os.mkdir(out_dir)
out_files.append(op.realpath(out_dir))
# Combine the transformations
run_rigid = self.inputs.rigids[i]
runtime, full_rigid = self.combine_rigids(runtime,
first_rigid,
run_rigid)
# Warp the timeseries files
run_timeseries = self.inputs.timeseries[i]
name = "res4d" if self.inputs.residual else "timeseries"
out_timeseries = op.join(out_dir, name + "_xfm.nii.gz")
runtime = self.apply_fsl_rigid(runtime, run_timeseries,
out_timeseries, full_rigid)
# Warp the mask file
run_mask = self.inputs.masks[i]
out_mask_fname = op.basename(add_suffix(run_mask, "xfm"))
out_mask = op.join(out_dir, out_mask_fname)
runtime = self.apply_fsl_rigid(runtime, run_mask,
out_mask, full_rigid)
# Warp the mean file
run_mean = self.inputs.means[i]
out_mean_fname = op.basename(add_suffix(run_mean, "xfm"))
out_mean = op.join(out_dir, out_mean_fname)
runtime = self.apply_fsl_rigid(runtime, run_mean,
out_mean, full_rigid)
# Copy the matrix to go from this space to the anatomy
if not i:
tkreg_fname = op.basename(self.inputs.tkreg_rigid)
out_tkreg = op.join(out_dir, tkreg_fname)
shutil.copyfile(self.inputs.tkreg_rigid, out_tkreg)
self.out_files = out_files
return runtime
def _run_interface(self, runtime):
n_runs = len(self.inputs.rigids)
if isdefined(self.inputs.first_rigid):
first_rigid = self.inputs.first_rigid
else:
first_rigid = self.inputs.rigids[0]
out_files = []
for i in range(n_runs):
# Set up the output directory
out_dir = "run_{}/".format(i + 1)
os.mkdir(out_dir)
out_files.append(op.realpath(out_dir))
# Combine the transformations
run_rigid = self.inputs.rigids[i]
runtime, full_rigid = self.combine_rigids(runtime, first_rigid,
run_rigid)
# Warp the timeseries files
run_timeseries = self.inputs.timeseries[i]
name = "res4d" if self.inputs.residual else "timeseries"
out_timeseries = op.join(out_dir, name + "_xfm.nii.gz")
runtime = self.apply_fsl_rigid(runtime, run_timeseries,
out_timeseries, full_rigid)
# Warp the mask file
run_mask = self.inputs.masks[i]
out_mask_fname = op.basename(add_suffix(run_mask, "xfm"))
out_mask = op.join(out_dir, out_mask_fname)
runtime = self.apply_fsl_rigid(runtime, run_mask, out_mask,
full_rigid)
# Warp the mean file
run_mean = self.inputs.means[i]
out_mean_fname = op.basename(add_suffix(run_mean, "xfm"))
out_mean = op.join(out_dir, out_mean_fname)
runtime = self.apply_fsl_rigid(runtime, run_mean, out_mean,
full_rigid)
# Copy the matrix to go from this space to the anatomy
if not i:
tkreg_fname = op.basename(self.inputs.tkreg_rigid)
out_tkreg = op.join(out_dir, tkreg_fname)
shutil.copyfile(self.inputs.tkreg_rigid, out_tkreg)
self.out_files = out_files
return runtime
def apply_ants_warp(self, runtime, in_file, out_file, rigid):
out_rigid = op.basename(add_suffix(out_file, "anat"))
continuous_interp = dict(trilinear="trilin",
spline="cubic")[self.interp]
interp = "nearest" if "mask" in in_file else continuous_interp
cmdline_rigid = ["mri_vol2vol",
"--mov", in_file,
"--reg", rigid,
"--fstarg",
"--" + interp,
"--o", out_rigid,
"--no-save-reg"]
runtime = submit_cmdline(runtime, cmdline_rigid)
continuous_interp = dict(trilinear="trilin",
spline="BSpline")[self.interp]
interp = "NN" if "mask" in in_file else continuous_interp
cmdline_warp = ["WarpImageMultiTransform",
"3",
out_rigid,
out_file,
self.inputs.warpfield,
self.inputs.affine,
"-R", self.ref_file]
if interp != "trilin":
cmdline_warp.append("--use-" + interp)
runtime = submit_cmdline(runtime, cmdline_warp)
return runtime
def combine_rigids(self, runtime, first_rigid, second_rigid):
"""Invert the first rigid and combine with the second.
This creates a transformation from run n to run 1 space,
through the anatomical coregistration.
"""
first_inv = op.basename(add_suffix(first_rigid, "inv"))
cmdline_inv = [
"convert_xfm", "-omat", first_inv, "-inverse", first_rigid
]
runtime = submit_cmdline(runtime, cmdline_inv)
full_rigid = op.basename(add_suffix(second_rigid, "to_epi"))
cmdline_full = [
"convert_xfm", "-omat", full_rigid, "-concat", first_inv,
second_rigid
]
runtime = submit_cmdline(runtime, cmdline_full)
return runtime, full_rigid
def _run_interface(self, runtime):
n_runs = len(self.inputs.rigids)
if isdefined(self.inputs.first_rigid):
first_rigid = self.inputs.first_rigid
else:
first_rigid = self.inputs.rigids[0]
# Unpack the long file lists to be ordered by run
copes = self.unpack_files("copes", n_runs)
varcopes = self.unpack_files("varcopes", n_runs)
sumsquares = self.unpack_files("sumsquares", n_runs)
out_files = []
for i in range(n_runs):
# Set up the output directory
out_dir = "run_{}/".format(i + 1)
os.mkdir(out_dir)
out_files.append(op.realpath(out_dir))
# Combine the transformations
run_rigid = self.inputs.rigids[i]
runtime, full_rigid = self.combine_rigids(runtime,
first_rigid,
run_rigid)
# Select the files for this run
run_copes = copes[i]
run_varcopes = varcopes[i]
run_sumsquares = sumsquares[i]
run_mask = [self.inputs.masks[i]]
run_mean = [self.inputs.means[i]]
all_files = (run_copes + run_varcopes +
run_sumsquares + run_mask + run_mean)
# Apply the transformation to each file
for in_file in all_files:
out_fname = op.basename(add_suffix(in_file, "xfm"))
out_file = op.join(out_dir, out_fname)
runtime = self.apply_fsl_rigid(runtime, in_file,
out_file, full_rigid)
# Copy the matrix to go from this space to the anatomy
if not i:
tkreg_fname = op.basename(self.inputs.tkreg_rigid)
out_tkreg = op.join(out_dir, tkreg_fname)
shutil.copyfile(self.inputs.tkreg_rigid, out_tkreg)
self.out_files = out_files
return runtime
def combine_rigids(self, runtime, first_rigid, second_rigid):
"""Invert the first rigid and combine with the second.
This creates a transformation from run n to run 1 space,
through the anatomical coregistration.
"""
first_inv = op.basename(add_suffix(first_rigid, "inv"))
cmdline_inv = ["convert_xfm",
"-omat", first_inv,
"-inverse",
first_rigid]
runtime = submit_cmdline(runtime, cmdline_inv)
full_rigid = op.basename(add_suffix(second_rigid, "to_epi"))
cmdline_full = ["convert_xfm",
"-omat", full_rigid,
"-concat", first_inv,
second_rigid]
runtime = submit_cmdline(runtime, cmdline_full)
return runtime, full_rigid
def _run_interface(self, runtime):
n_runs = len(self.inputs.rigids)
if isdefined(self.inputs.first_rigid):
first_rigid = self.inputs.first_rigid
else:
first_rigid = self.inputs.rigids[0]
# Unpack the long file lists to be ordered by run
copes = self.unpack_files("copes", n_runs)
varcopes = self.unpack_files("varcopes", n_runs)
sumsquares = self.unpack_files("sumsquares", n_runs)
out_files = []
for i in range(n_runs):
# Set up the output directory
out_dir = "run_{}/".format(i + 1)
os.mkdir(out_dir)
out_files.append(op.realpath(out_dir))
# Combine the transformations
run_rigid = self.inputs.rigids[i]
runtime, full_rigid = self.combine_rigids(runtime, first_rigid,
run_rigid)
# Select the files for this run
run_copes = copes[i]
run_varcopes = varcopes[i]
run_sumsquares = sumsquares[i]
run_mask = [self.inputs.masks[i]]
run_mean = [self.inputs.means[i]]
all_files = (run_copes + run_varcopes + run_sumsquares + run_mask +
run_mean)
# Apply the transformation to each file
for in_file in all_files:
out_fname = op.basename(add_suffix(in_file, "xfm"))
out_file = op.join(out_dir, out_fname)
runtime = self.apply_fsl_rigid(runtime, in_file, out_file,
full_rigid)
# Copy the matrix to go from this space to the anatomy
if not i:
tkreg_fname = op.basename(self.inputs.tkreg_rigid)
out_tkreg = op.join(out_dir, tkreg_fname)
shutil.copyfile(self.inputs.tkreg_rigid, out_tkreg)
self.out_files = out_files
return runtime
def _run_interface(self, runtime):
# Get a reference to either the ANTS or FSL function
method_name = "apply_{}_warp".format(self.inputs.method)
warp_func = getattr(self, method_name)
n_runs = len(self.inputs.rigids)
out_files = []
for i in range(n_runs):
# Set up the output directory
out_dir = "run_{}/".format(i + 1)
os.mkdir(out_dir)
out_files.append(op.realpath(out_dir))
# Warp the timeseries files
run_timeseries = self.inputs.timeseries[i]
name = "res4d" if self.inputs.residual else "timeseries"
out_timeseries = op.join(out_dir, name + "_warp.nii.gz")
run_rigid = self.inputs.rigids[i]
runtime = warp_func(runtime, run_timeseries,
out_timeseries, run_rigid)
# Warp the mask file
run_mask = self.inputs.masks[i]
out_mask_fname = op.basename(add_suffix(run_mask, "warp"))
out_mask = op.join(out_dir, out_mask_fname)
runtime = warp_func(runtime, run_mask, out_mask, run_rigid)
# Warp the mean file
run_mean = self.inputs.means[i]
out_mean_fname = op.basename(add_suffix(run_mean, "warp"))
out_mean = op.join(out_dir, out_mean_fname)
runtime = warp_func(runtime, run_mean, out_mean, run_rigid)
self.out_files = out_files
return runtime
def _run_interface(self, runtime):
# Get a reference to either the ANTS or FSL function
method_name = "apply_{}_warp".format(self.inputs.method)
warp_func = getattr(self, method_name)
n_runs = len(self.inputs.rigids)
out_files = []
for i in range(n_runs):
# Set up the output directory
out_dir = "run_{}/".format(i + 1)
os.mkdir(out_dir)
out_files.append(op.realpath(out_dir))
# Warp the timeseries files
run_timeseries = self.inputs.timeseries[i]
name = "res4d" if self.inputs.residual else "timeseries"
out_timeseries = op.join(out_dir, name + "_warp.nii.gz")
run_rigid = self.inputs.rigids[i]
runtime = warp_func(runtime, run_timeseries, out_timeseries,
run_rigid)
# Warp the mask file
run_mask = self.inputs.masks[i]
out_mask_fname = op.basename(add_suffix(run_mask, "warp"))
out_mask = op.join(out_dir, out_mask_fname)
runtime = warp_func(runtime, run_mask, out_mask, run_rigid)
# Warp the mean file
run_mean = self.inputs.means[i]
out_mean_fname = op.basename(add_suffix(run_mean, "warp"))
out_mean = op.join(out_dir, out_mean_fname)
runtime = warp_func(runtime, run_mean, out_mean, run_rigid)
self.out_files = out_files
return runtime
def _run_interface(self, runtime):
# Get a reference to either the ANTS or FSL function
method_name = "apply_{}_warp".format(self.inputs.method)
warp_func = getattr(self, method_name)
# Unpack the long file lists to be ordered by run
n_runs = len(self.inputs.rigids)
copes = self.unpack_files("copes", n_runs)
varcopes = self.unpack_files("varcopes", n_runs)
sumsquares = self.unpack_files("sumsquares", n_runs)
out_files = []
for i in range(n_runs):
# Set up the output directory
out_dir = "run_{}/".format(i + 1)
os.mkdir(out_dir)
out_files.append(op.realpath(out_dir))
# Select the files for this run
run_rigid = self.inputs.rigids[i]
run_copes = copes[i]
run_varcopes = varcopes[i]
run_sumsquares = sumsquares[i]
run_mask = [self.inputs.masks[i]]
run_mean = [self.inputs.means[i]]
all_files = (run_copes + run_varcopes +
run_sumsquares + run_mask + run_mean)
# Apply the transformation to each file
for in_file in all_files:
out_fname = op.basename(add_suffix(in_file, "warp"))
out_file = op.join(out_dir, out_fname)
runtime = warp_func(runtime, in_file, out_file, run_rigid)
self.out_files = out_files
return runtime
def _run_interface(self, runtime):
# Get a reference to either the ANTS or FSL function
method_name = "apply_{}_warp".format(self.inputs.method)
warp_func = getattr(self, method_name)
# Unpack the long file lists to be ordered by run
n_runs = len(self.inputs.rigids)
copes = self.unpack_files("copes", n_runs)
varcopes = self.unpack_files("varcopes", n_runs)
sumsquares = self.unpack_files("sumsquares", n_runs)
out_files = []
for i in range(n_runs):
# Set up the output directory
out_dir = "run_{}/".format(i + 1)
os.mkdir(out_dir)
out_files.append(op.realpath(out_dir))
# Select the files for this run
run_rigid = self.inputs.rigids[i]
run_copes = copes[i]
run_varcopes = varcopes[i]
run_sumsquares = sumsquares[i]
run_mask = [self.inputs.masks[i]]
run_mean = [self.inputs.means[i]]
all_files = (run_copes + run_varcopes + run_sumsquares + run_mask +
run_mean)
# Apply the transformation to each file
for in_file in all_files:
out_fname = op.basename(add_suffix(in_file, "warp"))
out_file = op.join(out_dir, out_fname)
runtime = warp_func(runtime, in_file, out_file, run_rigid)
self.out_files = out_files
return runtime
def apply_ants_warp(self, runtime, in_file, out_file, rigid):
out_rigid = op.basename(add_suffix(out_file, "anat"))
continuous_interp = dict(trilinear="trilin",
spline="cubic")[self.interp]
interp = "nearest" if "mask" in in_file else continuous_interp
cmdline_rigid = [
"mri_vol2vol", "--mov", in_file, "--reg", rigid, "--fstarg",
"--" + interp, "--o", out_rigid, "--no-save-reg"
]
runtime = submit_cmdline(runtime, cmdline_rigid)
continuous_interp = dict(trilinear="trilin",
spline="BSpline")[self.interp]
interp = "NN" if "mask" in in_file else continuous_interp
cmdline_warp = [
"WarpImageMultiTransform", "3", out_rigid, out_file,
self.inputs.warpfield, self.inputs.affine, "-R", self.ref_file
]
if interp != "trilin":
cmdline_warp.append("--use-" + interp)
runtime = submit_cmdline(runtime, cmdline_warp)
return runtime
