def directInvokeAlgorithm(self,vals):
print('oooo invoking: nonLinearRegistration', (vals));
target = self.inputs['target'];
reference = self.inputs['reference'];
transform = self.inputs['initial'];
linearmode = bis_baseutils.getLinearModeCode(vals['linearmode']);
initial=transform;
if (linearmode>=0):
try:
mat=libbis.runLinearRegistrationWASM(reference, target, transform, {
'intscale' : vals['intscale'],
'numbins' : vals['numbins'],
'levels' : vals['levels'],
'smoothing' : vals['extrasmoothing'],
'optimization' : bis_baseutils.getOptimizationCode(vals['optimization']),
'stepsize' : vals['stepsize'],
'metric' : bis_baseutils.getMetricCode(vals['metric']),
'steps' : vals['steps'],
'iterations' : vals['iterations'],
'normalize' : self.parseBoolean(vals['norm']),
'debug' : self.parseBoolean(vals['debug']),
'mode' : linearmode,
'resolution' : vals['resolution'],
'return_vector' : False}, self.parseBoolean(vals['debug']));
initial=bis_objects.bisLinearTransformation();
initial.create(mat);
except:
print('Failed to invoke linear registration algorithm.');
return False;
try:
self.outputs['output']=libbis.runNonLinearRegistrationWASM(reference, target, initial, {
'cps' : vals['cps'],
'lambda' : vals['lambda'],
'intscale' : vals['intscale'],
'numbins' : vals['numbins'],
'levels' : vals['levels'],
'smoothing' : vals['extrasmoothing'],
'optimization' : bis_baseutils.getOptimizationCode(vals['optimization']),
'stepsize' : vals['stepsize'],
'debug' : self.parseBoolean(vals['debug']),
'normalize' : self.parseBoolean(vals['norm']),
'metric' : bis_baseutils.getMetricCode(vals['metric']),
'steps' : vals['steps'],
'iterations' : vals['iterations'],
'resolution' : vals['resolution']}, self.parseBoolean(vals['debug']));
if (self.parseBoolean(vals['doreslice'])==True):
self.outputs['resliced']=bis_baseutils.resliceRegistrationOutput(libbis,reference,
target,self.outputs['output']);
except:
print('---- Failed to invoke nonlinear registration algorithm.');
return False
return True
def directInvokeAlgorithm(self, vals):
print('oooo invoking: linearRegistration', (vals))
target = self.inputs['target']
reference = self.inputs['reference']
transform = self.inputs['initial']
if (reference.hasSameOrientation(target, 'Reference Image',
'Target Image', True) == False):
return False
try:
out = libbis.runLinearRegistrationWASM(
reference, target, transform, {
'intscale':
vals['intscale'],
'numbins':
vals['numbins'],
'levels':
vals['levels'],
'smoothing':
vals['imagesmoothing'],
'optimization':
bis_baseutils.getOptimizationCode(vals['optimization']),
'stepsize':
vals['stepsize'],
'metric':
bis_baseutils.getMetricCode(vals['metric']),
'steps':
vals['steps'],
'normalize':
self.parseBoolean(vals['norm']),
'debug':
self.parseBoolean(vals['debug']),
'iterations':
vals['iterations'],
'mode':
bis_baseutils.getLinearModeCode(vals['mode']),
'resolution':
vals['resolution'],
'return_vector':
False
}, self.parseBoolean(vals['debug']))
self.outputs['output'] = bis_objects.bisLinearTransformation()
self.outputs['output'].create(out)
if (self.parseBoolean(vals['doreslice']) == True):
self.outputs[
'resliced'] = bis_baseutils.resliceRegistrationOutput(
libbis, reference, target, self.outputs['output'])
except:
e = sys.exc_info()[0]
print('---- Failed to invoke algorithm', e)
return False
return True
def test_resample_module(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('----------------------------------------------------------')
xformname = my_path + '/testdata/newtests/reslice_transform.matr'
xform = bis.bisLinearTransformation()
xform.load(xformname)
module = resliceImage.resliceImage()
reference_image = images[0]
target_image = images[1]
true_image = images[2]
module.execute(
{
'input': target_image,
'reference': reference_image,
'transform': xform
}, {'debug': True})
out_obj = module.getOutputObject('output')
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 module reslicing correlation out v true=', cc, 'pass='******'----------------------------------------------------------------------'
)
self.assertEqual(testpass, True)
def test_bis_eigenutils(self):
print('test_eigenUtils')
m = np.identity(4, dtype=np.float32)
for row in range(0, 4):
for col in range(0, 4):
m[row][col] = (1.0 + row) * 10.0 + col * col * 5.0
xform = bis.bisLinearTransformation().create(m)
print('First print to check ...\n', xform.get_data())
vect = bis.bisVector().create(np.array([1, 2, 3, 5, 7, 11.0]))
numfailed = libbiswasm.test_eigenUtils(xform, vect, 1)
print('\t From JS to C++, numfailed=', numfailed)
self.assertEqual(numfailed, 0)
def deserialize_object(ptr, datatype='', offset=0, first_input=0):
if datatype == '':
datatype = getNameFromMagicCode(magic_code)
if datatype == 'String':
output = bis.bisVector()
output.deserializeWasm(ptr, offset)
return output.getString()
if datatype == 'Matrix':
output = bis.bisMatrix()
output.deserializeWasm(ptr, offset)
return output.get_data()
if datatype == 'Vector':
output = bis.bisVector()
output.deserializeWasm(ptr, offset)
return output.get_data()
if datatype == 'bisComboTransformation':
output = bis.bisComboTransformation()
output.deserializeWasm(ptr, offset)
return output
if datatype == 'bisGridTransformation':
output = bis.bisGridTransformation()
output.deserializeWasm(ptr, offset)
return output
if datatype == 'bisLinearTransformation':
output = bis.bisLinearTransformation()
output.deserializeWasm(ptr, offset)
return output.get_data()
if datatype != 'bisImage':
raise ValueError('Unknown datatype ', datatype)
# Image from here
output = bis.bisImage()
output.deserializeWasm(ptr, offset)
if type(first_input) is bis.bisImage:
output.affine = first_input.affine
return output
def processTestResult(toolname, resultFile, test_target, test_type,
test_threshold, test_comparison):
threshold = test_threshold
if (threshold == None):
threshold = 0.01
comparison = test_comparison
if (comparison == None):
comparison = "maxabs"
if (test_type == 'image'):
if (comparison != "maxabs" and comparison != "ssd"):
comparison = "cc"
if (test_type == 'matrix' or test_type == "matrixtransform"
or test_type == "gridtransform"):
if (comparison != "maxabs"):
comparison = "ssd"
print(
'====\n==================================================================\n===='
)
print('==== comparing ', test_type, ' using ', comparison,
' and threshold=', threshold, '.\n====')
print('==== files=', resultFile, test_target)
if (test_type == "image"):
out = bis_objects.bisImage()
if (out.load(resultFile) != False):
gold = bis_objects.bisImage()
if (gold.load(test_target) != False):
diff = 0
if (comparison == 'cc'):
diff = -computeCC(out.get_data(), gold.get_data())
threshold = -threshold
elif comparison == 'ssd':
diff = computeNorm2(out.get_data(), gold.get_data())
else:
diff = maxabsdiff(gold.get_data(), out.get_data())
return printResult(diff, threshold, toolname, test_type)
else:
print('---- Failed to load gold standard image')
return False
else:
print('---- Failed to load input image')
return False
elif (test_type == "matrix"):
out = bis_objects.bisMatrix()
if (out.load(resultFile) != False):
gold = bis_objects.bisMatrix()
if (gold.load(test_target) != False):
print('out ', resultFile, ' dims=', out.data_array.shape)
print('gold ', test_target, ' dims=', gold.data_array.shape)
if (comparison == 'maxabs'):
diff = maxabsdiff(gold.data_array, out.data_array)
else:
diff = computeNorm2(gold.data_array, out.data_array)
return printResult(diff, threshold, toolname, test_type)
else:
return False
else:
return False
elif (test_type == "matrixtransform"):
out = bis_objects.bisLinearTransformation()
if (out.load(resultFile) != False):
gold = bis_objects.bisLinearTransformation()
if (gold.load(test_target) != False):
print('out ', resultFile, ' dims=', out.data_array.shape)
print('gold ', test_target, ' dims=', gold.data_array.shape)
if (comparison == 'maxabs'):
diff = maxabsdiff(gold.data_array, out.data_array)
else:
diff = computeNorm2(gold.data_array, out.data_array)
return printResult(diff, threshold, toolname, test_type)
else:
return False
else:
return False
elif (test_type == "gridtransform"):
out = bis_objects.bisComboTransformation()
if (out.load(resultFile) != False):
print('out ', resultFile, ' dims=', out.grids[0].data_array.shape)
gold = bis_objects.bisComboTransformation()
if (gold.load(test_target) != False):
print('gold ', test_target, ' dims=',
gold.grids[0].data_array.shape)
if (comparison == 'maxabs'):
diff = maxabsdiff(gold.grids[0].data_array,
out.grids[0].data_array)
else:
diff = computeNorm2(gold.grids[0].data_array,
out.grids[0].data_array)
return printResult(diff, threshold, toolname, test_type)
else:
return False
else:
return False
print('---- Cannot compare type :', test_type)
return False
