def apply_transform(cls, reg_data, transform, options, queue):
"""
Apply a previously calculated transformation to a data set
We are not actually using FSL applyxfm for this although it would be
an alternative option for the reference space output option. Instead
we perform a non-lossy affine transformation and then resample onto
the reference or registration spaces as required.
"""
log = "Performing non-lossy affine transformation\n"
order = options.pop("interp-order", 1)
affine = transform.voxel_to_world(reg_data.grid)
grid = DataGrid(reg_data.grid.shape, affine)
qpdata = NumpyData(reg_data.raw(), grid=grid, name=reg_data.name)
output_space = options.pop("output-space", "ref")
if output_space == "ref":
qpdata = qpdata.resample(transform.ref_grid,
suffix="",
order=order)
log += "Resampling onto reference grid\n"
elif output_space == "reg":
qpdata = qpdata.resample(transform.reg_grid,
suffix="",
order=order)
log += "Resampling onto input grid\n"
return qpdata, log
def get_roi(self, options, grid=None, use_current=False):
"""
Standard method to get the ROI the process is to operate on
If no 'roi' option is specified, go with currently selected ROI,
if it exists.
:param options: Dictionary of options - ``roi`` will be consumed if present
:param grid: If specified, return ROI on this grid
:param use_current: If True, return current ROI if no ROI specified
:return: QpData instance. If no ROI can be found and ``grid`` is specified, will
return an ROI where all voxels are unmasked.
"""
roi_name = options.pop("roi", None)
if roi_name is None or roi_name.strip() == "":
if use_current and self.ivm.current_roi is not None:
roidata = self.ivm.current_roi
elif grid is not None:
roidata = NumpyData(np.ones(grid.shape[:3]), grid=grid, name="dummy_roi", roi=True)
else:
return None
else:
if roi_name in self.ivm.rois:
roidata = self.ivm.rois[roi_name]
else:
raise QpException("ROI not found: %s" % roi_name)
if grid is not None:
roidata = roidata.resample(grid)
return roidata
