dim = 2
device = 'GPU' # CPU or GPU
ASpace = AtomSpace(dim, isotropic=True)
vol = VolSpace(odl.uniform_discr([-1] * 2, [1] * 2, [128] * 2))
# Projection settings:
PSpace = ProjSpace(
odl.uniform_discr(0, pi, 30),
odl.uniform_discr(-1.5 * sqrt(dim), 1.5 * sqrt(dim), 128))
# Initiate Data:
#####
# # These lines initiate the 2 atom demo
gt = AtomElement(ASpace, x=[[-.5, 0], [.5, 0]], r=[.30, .10], I=1)
# recon = AtomElement(ASpace, [[.2, .5], [-.2, -.5]], [.18, .18], 1)
recon = ASpace.random(10, seed=1)
# # These lines generate random atoms
# nAtoms = 1 # 5
# gt = ASpace.random(nAtoms, seed=2) # 6, 10
# recon = ASpace.random(nAtoms)
# c.set(recon.r, 1, (slice(None), slice(None, 2)))
# c.set(recon.r, 0, (slice(None), slice(2, None)))
# c.set(recon.I[:], 1)
# c.set(gt.I[:], 1)
#####
nAtoms = recon.I.shape[0]
Radon = GaussTomo(ASpace, vol, PSpace, device=device)
gt_sino = Radon(gt)
gt_view = Radon.discretise(gt)
R = Radon(recon)
vol = VolSpace(odl.uniform_discr([-1] * 2, [1] * 2, [128] * 2))
# Projection settings:
PSpace = ProjSpace(
odl.uniform_discr(0, pi, 30),
odl.uniform_discr(-1.5 * sqrt(dim), 1.5 * sqrt(dim), 128))
# Initiate Data:
#####
# # These lines initiate the 2 atom demo
# gt = AtomElement(ASpace, x=[[-.5, 0], [.5, 0]], r=[.30, .10], I=1)
# recon = AtomElement(ASpace, [[.2, .5], [-.2, -.5]], [.18, .18], 1)
# recon = ASpace.random(10, seed=1)
# # These lines generate random atoms
nAtoms = 5 # 5
gt = ASpace.random(nAtoms, seed=2) # 6, 10
recon = ASpace.random(nAtoms)
c.set(gt.r, .1, (slice(None), slice(None, 2)))
c.set(recon.r, .1, (slice(None), slice(None, 2)))
# c.set(recon.r, 0, (slice(None), slice(2, None)))
# c.set(recon.I[:], 1)
# c.set(gt.I[:], 1)
# recon[nAtoms - 1] = gt[nAtoms - 1]
#####
nAtoms = recon.I.shape[0]
Radon = GaussTomo(ASpace, vol, PSpace, device=device)
data = Radon(gt)
gt_view = Radon.discretise(gt)
R = Radon(recon)
# Reconstruction:
if __name__ == '__main__':
import numpy as np
from matplotlib import pyplot as plt
sz = [256] * 3
x = _tomesh([10 * np.linspace(-.3, 1, s).astype('f4') for s in sz])
# x = _tomesh([10 * np.linspace(-.3, 1, sz[0]).astype('f4'),
# 10 * np.linspace(-.3, 1, sz[1]).astype('f4'),
# 10 * np.linspace(-.3, 1, sz[2]).astype('f4')])
k = _tomesh(GaussFT.getGrid(x))
vSpace = VolSpace(x)
fSpace = VolSpace(k)
aSpace = AtomSpace(dim=len(sz), isotropic=False)
a = aSpace.random(2, seed=2)
a.r[:, :3] = (3 + a.r[:, :3]) / (3 + 1)
a.r[:, 3:] = (0 + a.r[:, 3:]) / (3 + 1)
a.x[:] = (a.x + 1) * 2 + 4
# Ie^{-|R(x-m)|^2/2}
volRep = 0
for i in range(len(a)):
if len(sz) == 2:
X = [x[j] - a.x[i, j] for j in range(2)]
Rx = [a.r[i, 0] * X[0] + a.r[i, 2] * X[1], a.r[i, 1] * X[1]]
volRep += a.I[i] * exp(-(Rx[0] ** 2 + Rx[1] ** 2) / 2)
else:
X = [x[j] - a.x[i, j] for j in range(3)]
Rx = [
a.r[i, 0] * X[0] + a.r[i, 3] * X[1] + a.r[i, 5] * X[2],
# print(nP, n, abs(grad).max(), abs(Rp.asarray()).max())
# print((nP - n) / e, c.asarray(c.sum(c.mul(grad, da))))
# print(abs(nP - n - e * c.sum(c.mul(e, da))), log10(e))
print()
print('Finished after time: ', time() - tic)
if __name__ == '__main__':
from numpy import pi
import odl
from GaussDictCode.dictionary_def import VolSpace, ProjSpace, AtomSpace, ProjElement
from matplotlib import pyplot as plt
# # 2D comparison
ASpace = AtomSpace(2, isotropic=False)
atoms = ASpace.random(2, seed=1)
angles = odl.uniform_partition(0, 2 * pi, 360, nodes_on_bdry=True)
detector = odl.uniform_partition(-1, 1, 256)
vol = odl.uniform_partition([-1] * 2, [1] * 2, [128] * 2)
myPSpace = ProjSpace(angles, detector)
myTomo = GaussTomo(ASpace, VolSpace(vol), myPSpace, device='GPU')
mySino = myTomo(atoms)
odlPSpace = odl.tomo.Parallel2dGeometry(angles, detector)
odlTomo = odl.tomo.RayTransform(
odl.uniform_discr_frompartition(vol), odlPSpace)
odlSino = odlTomo(myTomo.discretise(atoms).asarray())
odlSino = ProjElement(myPSpace, odlSino.asarray())
mySino.plot(plt.subplot('211'), aspect='auto')
plt.title('2D Atomic Sinogram (top) and volume-sinogram (bottom)')
odlSino.plot(plt.subplot('212'), aspect='auto')
Radon = odl.tomo.RayTransform(vol, PSpace)
data = Radon(gt)
with myManager(device='cpu', order='C', fType='float32',
cType='complex64') as c:
# Space settings:
dim = 3
device = 'GPU'
ASpace = AtomSpace(dim, isotropic=False)
vol = VolSpace(odl.uniform_discr([-1] * 3, [1] * 3, gt.shape))
# Projection settings:
PSpace = ProjSpace(angles, odl.uniform_discr([-1] * 2, [1] * 2, [64] * 2))
nAtoms = 50
recon = ASpace.random(nAtoms, seed=1)
c.set(recon.x[:], c.mul(recon.x, 1 / 3))
c.set(recon.r, 10, (slice(None), slice(None, 3)))
c.set(recon.r, 0, (slice(None), slice(3, None)))
nAtoms = recon.I.shape[0]
Radon = GaussTomo(ASpace, vol, PSpace, device=device)
gt = VolElement(vol, gt)
R = Radon(recon)
data = ProjElement(PSpace, data.asarray().reshape(PSpace.shape))
# Reconstruction:
fidelity = l2_squared_loss(dim)
reg = null(dim)
def guess(d, a):
return doKL_ProjGDStep_iso(d, a, 1e-0, Radon)