def directInvokeAlgorithm(self, vals):
print('oooo invoking: resliceImage with vals', (vals))
input = self.inputs['input']
reference = self.inputs['reference']
if (reference == None):
reference = input
xform = self.inputs['xform']
spa = reference.spacing
dim = reference.dimensions
dt = "-1"
if (vals['forcefloat']):
dt = "float"
try:
self.outputs['output'] = libbis.resliceImageWASM(
input, xform, {
"spacing": [spa[0], spa[1], spa[2]],
"dimensions": [dim[0], dim[1], dim[2]],
"datatype": dt,
"interpolation": vals['interpolation']
}, self.parseBoolean(vals['debug']))
except:
print('---- Failed to invoke algorithm')
return False
return True
def test_resample(self):
imgnames = [
'avg152T1_LR_nifti_resampled.nii.gz', 'avg152T1_LR_nifti.nii.gz',
'avg152T1_LR_nifti_resampled_resliced.nii.gz'
]
images = [0, 0, 0]
names = [' reference', 'target', 'true']
print('\n\n')
print('----------------------------------------------------------')
for i in range(0, 3):
name = my_path + '/../test/testdata/' + imgnames[i]
images[i] = bis.bisImage().load(name)
print('__ loaded ', names[i], 'from ', name, 'dims=',
images[i].dimensions, images[i].spacing,
images[i].dimensions, images[i].get_data().dtype)
print('----------------------------------------------------------')
reslice_matr = [[0.866, -0.525, 0.000, 68.758],
[0.500, 0.909, 0.000, 9.793],
[0.000, 0.000, 1.000, 2.250],
[0.000, 0.000, 0.000, 1.000]]
matr = np.zeros([4, 4], dtype=np.float32)
for row in range(0, 4):
for col in range(0, 4):
matr[row][col] = reslice_matr[row][col]
reference_image = images[0]
target_image = images[1]
true_image = images[2]
paramobj = {
"interpolation": 1,
"dimensions": reference_image.dimensions,
"spacing": reference_image.spacing,
"datatype": "float",
"backgroundValue": 0.0,
}
print('----------------------------------------------------------')
out_obj = libbis.resliceImageWASM(images[1], matr, paramobj, debug=2)
cc = np.corrcoef(images[2].get_data().flatten(),
out_obj.get_data().flatten())[0, 1]
if cc > 0.999:
testpass = True
else:
testpass = False
print('----------------------------------------------------------')
print('__ post reslicing correlation out v true=', cc, 'pass='******'----------------------------------------------------------')
self.assertEqual(testpass, True)
if (fmri.dimensions != group.dimensions):
group_resliced = group;
print('++++ \t No reslicing required...');
else:
print('++++ \t Group parcellation being resliced to match the fMRI image dimension...');
resl_paramobj = {
"interpolation" : 0,
"dimensions" : fmri.dimensions,
"spacing" : fmri.spacing,
"datatype" : "short",
"backgroundValue" : 0.0,
};
matr=np.eye(4,dtype=np.float32);
group_resliced=libbiswasm.resliceImageWASM(group,matr,resl_paramobj,2);
print('++++ \t Group parcellation dims=',group_resliced.dimensions);
if (smooth == 0):
fmri_smoothed = fmri;
print('++++ \t No smoothing required...');
else:
print('++++ \t Smoothing fMRI image...');
c = smooth * 0.4247;
fmri_smoothed = libbiswasm.gaussianSmoothImageWASM(fmri,
paramobj={
"sigmas": [c, c, c],
"inmm": True,
"radiusfactor": 1.5,
def directInvokeAlgorithm(self, vals):
print('oooo invoking: individualizedParcellation with vals', vals)
debug = self.parseBoolean(vals['debug'])
fmri = self.inputs['fmri']
group = self.inputs['parc']
if (fmri.hasSameOrientation(group, 'fMRI Image', 'Group Parcellation',
True) == False):
return False
fmriDim = fmri.dimensions
groupDim = group.dimensions
# Reslice Group Parcellation if needed
if (fmriDim[0] != groupDim[0] or fmriDim[1] != groupDim[1]
or fmriDim[2] != groupDim[2]):
print(
'++++ \t Group parcellation being resliced to match the fMRI image dimension...'
)
resl_paramobj = {
"interpolation": 0,
"dimensions": fmri.dimensions,
"spacing": fmri.spacing,
"datatype": "short",
"backgroundValue": 0.0,
}
matr = np.eye(4, dtype=np.float32)
try:
print(
'++++ Reslicing group parcellation to match dimensions of individual fmri image'
)
group = libbis.resliceImageWASM(group, matr, resl_paramobj,
debug)
except:
e = sys.exc_info()[0]
print('---- Failed to invoke algorithm', e)
return False
print('++++ \t Group parcellation dims=', group.dimensions)
# Smooth If needed
smooth = vals['smooth']
if (smooth > 0.001):
print('++++ \t Smoothing fMRI image...')
c = smooth * 0.4247
smooth_paramobj = {
"sigmas": [c, c, c],
"inmm": True,
"radiusfactor": 1.5,
"vtkboundary": True,
}
try:
print('++++ Smoothing fmri Image')
fmri = libbis.gaussianSmoothImageWASM(fmri, smooth_paramobj,
debug)
except:
e = sys.exc_info()[0]
print('---- Failed to invoke algorithm', e)
return False
# Actual Parcellation
paramobj = {
'numberofexemplars': vals['numregions'],
'usefloat': self.parseBoolean(vals['usefloat']),
'saveexemplars': self.parseBoolean(vals['saveexemplars']),
}
try:
self.outputs['output'] = libbis.individualizedParcellationWASM(
fmri, group, paramobj, debug)
except:
e = sys.exc_info()[0]
print('---- Failed to invoke algorithm', e)
return False
return True