def test_ellipse_im(show_fig=False):
"""Basic test: only verifies that the phantoms have the expected shape."""
ig = ImageGeometry(shape=(2 ** 8, 2 ** 8 + 2), fov=250)
x0, params = ellipse_im(ig, "shepplogan", oversample=2)
assert x0.shape == ig.shape
x1, params = ellipse_im(ig, "shepplogan-emis", oversample=2)
assert x1.shape == ig.shape
x2, params = ellipse_im(ig, "shepplogan-mod", oversample=2)
assert x2.shape == ig.shape
def test_FiniteDifference_operator(xp, order):
e = ellipse_im(
ImageGeometry(shape=(256, 256), fov=256), params="shepplogan-mod"
)[0]
ec = e + 1j * e.T
# 2D without corners should match the TV Operator in 'iso' mode
TV = TV_Operator(
e.shape, arr_dtype=ec.dtype, tv_type="iso", order=order, **get_loc(xp)
)
FD_nocorner = FiniteDifferenceOperator(
e.shape,
arr_dtype=ec.dtype,
order=order,
use_corners=False,
**get_loc(xp),
)
xp.testing.assert_array_almost_equal(TV * ec, FD_nocorner * ec)
# with corners included, should have 4 directions for 2D input
FD = FiniteDifferenceOperator(
ec.shape,
arr_dtype=ec.dtype,
order=order,
use_corners=True,
**get_loc(xp),
)
y = FD * e
if order == "F":
assert_(y.shape[-1] == 4)
else:
assert_(y.shape[0] == 4)
# scipy compatibility
xp.testing.assert_array_equal(FD.H * (FD * e), FD.rmatvec(FD.matvec(e)))
def test_TV_gradient_complex(xp, order):
e = ellipse_im(ImageGeometry(shape=(256, 256), fov=256),
params="shepplogan-mod")[0]
ec = e + 1j * e.T
ec = xp.asarray(ec)
T2 = TV_Operator(e.shape, arr_dtype=ec.dtype, order=order, **get_loc(xp))
grad_complex = T2.gradient(ec)
xp.testing.assert_array_almost_equal(grad_complex.real,
grad_complex.imag.T)
from matplotlib import pyplot as plt
from mrrt.utils import ImageGeometry, ellipse_im
ig = ImageGeometry(shape=(2**8, 2**8 + 2), fov=250)
fig, axes = plt.subplots(1, 3, figsize=(12, 4))
for i, name in enumerate(["shepplogan", "shepplogan-emis", "shepplogan-mod"]):
phantom, params = ellipse_im(ig, name, oversample=2)
im = axes[i].imshow(
phantom.T,
interpolation="nearest",
cmap=plt.cm.gray, # vmin=0.9, vmax=1.1
)
axes[i].set_title(name)
axes[i].set_axis_off()
fig.colorbar(im,
ax=axes[i],
orientation="vertical",
fraction=0.1,
shrink=0.9)
plt.tight_layout()
plt.show()
def _test_mri_exp_approx1(
segments=4,
nx=64,
tmax=25e-3,
dt=5e-6,
autocorr=False,
use_rmap=True,
atype="hist,time,unif",
nhist=None,
ctest=True,
verbose=False,
tol=None,
):
if verbose:
from matplotlib import pyplot as plt
from pyvolplot import subplot_stack
ti = np.arange(0, tmax, dt)
if True:
# Generate a synthetic fieldmap
fmap = np.zeros((64, 64))
fmap[6:27, 9:20] = 90
fmap[36:57, 9:20] = 120
fmap[5:26, 29:60] = 30
fmap[37:58, 29:60] = 60
if nx != 64:
fmap = ndi.zoom(fmap, nx / 64, order=0)
kernel_size = int(np.round(5 * nx / 64))
smoothing_kernel = np.ones(
(kernel_size, kernel_size)) / (kernel_size**2)
ndi.convolve(fmap, smoothing_kernel, output=fmap)
fmap = fmap + 10
if verbose:
plt.figure()
plt.imshow(fmap, interpolation="nearest", cmap="gray")
plt.title("Field Map")
if use_rmap:
# generate a T2 relaxation map
rmap = (np.asarray([[0, 0, 18, 23, 0, 20 * 64 / nx],
[6, 0, 8, 8, 0, 3 * 64 / nx]]) * nx / 64)
ig = ImageGeometry(shape=(nx, nx), fov=(nx, nx))
rmap, params = 1 * ellipse_im(ig, rmap, oversample=3)
if verbose:
plt.figure()
plt.imshow(rmap, cmap="gray", interpolation="nearest")
plt.title("Relax Map"),
else:
rmap = 0
zmap = rmap + (2j * np.pi) * fmap
if not nhist:
if not np.any(rmap > 0):
nhist = [40]
else:
nhist = [40, 10]
# autocorr_arg = ['autocorr', True] # test autocorrelation version
if True: # convert to single precision
ti = np.asarray(ti, dtype="float32")
zmap = np.asarray(zmap, dtype="complex64") # single precision complex
if isinstance(segments, int):
pass
elif isinstance(segments, (list, tuple)) and len(segments) == 2:
pass
else:
raise ValueError("Invalid choice for segments")
kwargs = {"autocorr": autocorr, "ctest": ctest, "verbose": verbose}
tstart = time.time()
if tol is None:
B, C, hk, zk = mri_exp_approx(ti,
zmap,
segments,
approx_type=(atype, nhist),
**kwargs)
else:
B, C, hk, zk = mri_exp_approx(ti,
zmap, [segments, tol],
approx_type=(atype, nhist),
**kwargs)
print("\tduration=%g s" % (time.time() - tstart))
if ctest:
Eh = np.exp(-ti[:, np.newaxis] * zk.ravel()[np.newaxis, :])
else:
Eh = np.exp(-ti[:, np.newaxis] * zmap.ravel()[np.newaxis, :])
Ep = np.dot(B, C) # matrix product
err = np.abs(Eh - Ep)
mse = np.mean(np.power(err, 2), axis=0)
if ctest:
wrms = np.sqrt(np.dot(mse, hk) / np.sum(hk))
else:
wrms = -1
if verbose:
subplot_stack(1000 * ti,
B,
title="Basis Components",
colors=["k", "m"])
nf = np.floor(nhist[0] / 4)
if len(nhist) == 2:
ik = np.array([0, nf, 2 * nf, 3 * nf, nhist[1] - 1
]) + 2 * nf * nhist[1]
ik = ik.tolist()
elif len(nhist) == 1:
ik = [0, nf, 2 * nf, 3 * nf, nhist[0] - 1]
ik = np.asarray(ik, dtype=int)
mse_mean = mse.mean()
max_err = err.max()
if verbose:
fig = subplot_stack(1000 * ti, Eh[:, ik], colors=["g", "k"])
fig = subplot_stack(
1000 * ti,
Ep[:, ik],
colors=["b--", "r--"],
fig=fig,
title="True and Approx",
)
fig = subplot_stack(
1000 * ti,
err[:, ik],
colors=["b--", "r--"],
title="True and Approx",
)
print("\tfor L=%d, wrms=%g, mse = %g, max_err=%g" %
(B.shape[1], wrms, mse_mean, max_err))
return wrms, mse_mean, max_err