def test_main(rec=False, verb=False, throw=True):
pet.MessageRedirector()
for scheme in ("file", "memory"):
pet.AcquisitionData.set_storage_scheme(scheme)
original_verb = pet.get_verbosity()
pet.set_verbosity(False)
# create an acq_model that is explicitly a RayTracingMatrix
am = pet.AcquisitionModelUsingRayTracingMatrix()
# load sample data
data_path = pet.examples_data_path('PET')
raw_data_file = pet.existing_filepath(data_path,
'Utahscat600k_ca_seg4.hs')
ad = pet.AcquisitionData(raw_data_file)
# create sample image
image = pet.ImageData()
image.initialise(dim=(31, 111, 111), vsize=(2.25, 2.25, 2.25))
# set up Acquisition Model
am.set_up(ad, image)
# test for adjointnesss
if not is_operator_adjoint(am, verbose=verb):
raise AssertionError(
'AcquisitionModelUsingRayTracingMatrix is not adjoint')
# Reset original verbose-ness
pet.set_verbosity(original_verb)
return 0, 1
def test_main(rec=False, verb=False, throw=True):
datafile = RE_PYEXT.sub(".txt", __file__)
test = pTest(datafile, rec, throw=throw)
test.verbose = verb
data_path = examples_data_path('MR')
AcquisitionData.set_storage_scheme('memory')
input_data = AcquisitionData(
data_path + '/simulated_MR_2D_cartesian_Grappa2.h5')
test.check(input_data.norm())
prep_gadgets = ['RemoveROOversamplingGadget']
processed_data = input_data.process(prep_gadgets)
test.check(processed_data.norm())
recon = CartesianGRAPPAReconstructor()
recon.compute_gfactors(False)
recon.set_input(processed_data)
recon.process()
complex_images = recon.get_output()
test.check(complex_images.norm())
csms = CoilSensitivityData()
processed_data.sort()
csms.calculate(processed_data)
am = AcquisitionModel(processed_data, complex_images)
am.set_coil_sensitivity_maps(csms)
fwd_acqs = am.forward(complex_images)
fwd_acqs_norm = fwd_acqs.norm()
test.check(fwd_acqs_norm, rel_tol = 1e-2)
acqs_diff = fwd_acqs - processed_data
rr = acqs_diff.norm()/fwd_acqs_norm
test.check(rr, abs_tol = 1e-4)
bwd_images = am.backward(processed_data)
imgs_diff = bwd_images - complex_images
rd = imgs_diff.norm()/complex_images.norm()
test.check(rd, abs_tol = 1e-4)
if not is_operator_adjoint(am, max_err = 1e-3):
raise AssertionError("Gadgetron operator is not adjoint")
return test.failed, test.ntest
def test_main(rec=False, verb=False, throw=True):
# Set STIR verbosity to off
original_verb = pet.get_verbosity()
pet.set_verbosity(1)
time.sleep(0.5)
sys.stderr.write("Testing NiftyPET projector...")
time.sleep(0.5)
# Get image
image = get_image()
# Get AM
try:
acq_model = pet.AcquisitionModelUsingNiftyPET()
except:
return 1, 1
acq_model.set_cuda_verbosity(verb)
data_path = examples_data_path('PET')
# raw_data_path = pet.existing_filepath(os.path.join(data_path, 'mMR'), 'mMR_template_span11.hs')
raw_data_path = os.path.join(data_path, 'mMR')
template_acq_data = pet.AcquisitionData(
os.path.join(raw_data_path, 'mMR_template_span11.hs'))
acq_model.set_up(template_acq_data, image)
# Test operator adjointness
if verb:
print('testing adjointness')
if not is_operator_adjoint(acq_model, num_tests=1, verbose=True):
raise AssertionError('NiftyPet AcquisitionModel is not adjoint')
# Generate test data
simulated_acq_data = acq_model.forward(image)
simulated_acq_data_w_noise = add_noise(simulated_acq_data, 10)
obj_fun = pet.make_Poisson_loglikelihood(template_acq_data)
obj_fun.set_acquisition_model(acq_model)
recon = pet.OSMAPOSLReconstructor()
recon.set_objective_function(obj_fun)
recon.set_num_subsets(1)
recon.set_num_subiterations(1)
recon.set_input(simulated_acq_data_w_noise)
if verb:
print('setting up, please wait...')
initial_estimate = image.get_uniform_copy()
recon.set_up(initial_estimate)
if verb:
print('reconstructing...')
recon.set_current_estimate(initial_estimate)
recon.process()
reconstructed_im = recon.get_output()
if not reconstructed_im:
raise AssertionError()
# Reset original verbose-ness
pet.set_verbosity(original_verb)
return 0, 1
def try_niftymomo(na):
time.sleep(0.5)
sys.stderr.write(
'\n# --------------------------------------------------------------------------------- #\n'
)
sys.stderr.write(
'# Starting NiftyMomMo test...\n')
sys.stderr.write(
'# --------------------------------------------------------------------------------- #\n'
)
time.sleep(0.5)
# The forward and the adjoint should meet the following criterion:
# | < x, Ty > - < y, Tsx > | / 0.5 * (| < x, Ty > | + | < y, Tsx > |) < epsilon
# for all images x and y, where T is the transform and Ts is the adjoint.
x = ref_aladin
T = na.get_transformation_matrix_forward()
y = flo_aladin
# Add in a magnification to make things interesting
t = T.as_array()
t[0][0] = 1.5
T = sirf.Reg.AffineTransformation(t)
# make it slightly unsquare to spice things up
min_idx = [0, 1, 2]
y_dims = y.get_dimensions()
max_idx = [y_dims[1] - 3, y_dims[2] - 1, y_dims[3] - 5]
y.crop(min_idx, max_idx)
sys.stderr.write('Testing adjoint resample...\n')
nr = sirf.Reg.NiftyResampler()
nr.set_reference_image(x)
nr.set_floating_image(y)
nr.set_interpolation_type_to_linear()
nr.add_transformation(T)
# Check the adjoint is truly the adjoint with: |<x, Ty> - <y, Tsx>| / 0.5*(|<x, Ty>|+|<y, Tsx>|) < epsilon
if not is_operator_adjoint(nr):
raise AssertionError("NiftyResampler::adjoint() failed")
# Check that the following give the same result
# out = resample.adjoint(in)
# resample.adjoint(out, in)
out1 = nr.adjoint(x)
out2 = y.deep_copy()
nr.backward(out=out2, x=x)
if out1 != out2:
raise AssertionError(
'out = NiftyResampler::adjoint(in) and NiftyResampler::adjoint(out, in) do not give same result.'
)
time.sleep(0.5)
sys.stderr.write(
'\n# --------------------------------------------------------------------------------- #\n'
)
sys.stderr.write(
'# Finished NiftyMoMo test.\n')
sys.stderr.write(
'# --------------------------------------------------------------------------------- #\n'
)
time.sleep(0.5)