nth = np.int(sys.argv[2])
name = sys.argv[3]
binning = 1
data = np.zeros([ndsets*nth,2048//pow(2,binning),2448//pow(2,binning)],dtype='float32')
theta = np.zeros(ndsets*nth,dtype='float32')
for k in range(ndsets):
data[k*nth:(k+1)*nth] = np.load(name+'_bin'+str(binning)+str(k)+'.npy').astype('float32')
theta[k*nth:(k+1)*nth] = np.load(name+'_theta'+str(k)+'.npy').astype('float32')
[ntheta, nz, n] = data.shape # object size n x,y
data[np.isnan(data)]=0
data-=np.mean(data)
# pad data
ne = 3584//pow(2,binning)
#ne=n
print(data.shape)
# data=prealign(data)
center = centers[sys.argv[3]]+(ne//2-n//2)*pow(2,binning)
pnz = 8*pow(2,binning) # number of slice partitions for simultaneous processing in tomography
u = np.zeros([nz, ne, ne], dtype='float32')
with tc.SolverTomo(np.array(theta[::2],order='C'), ntheta//2, nz, ne, pnz, center/pow(2, binning), ngpus) as tslv:
ucg = tslv.cg_tomo_batch(pad(np.array(data[::2],order='C'),ne,n),u,64)
dxchange.write_tiff_stack(
ucg[:,ne//2-n//2:ne//2+n//2,ne//2-n//2:ne//2+n//2], name+'/cgn_resolution1_'+'_'+str(ntheta//2)+'/rect'+str(k)+'/r', overwrite=True)
with tc.SolverTomo(np.array(theta[1::2],order='C'), ntheta//2, nz, ne, pnz, center/pow(2, binning), ngpus) as tslv:
ucg = tslv.cg_tomo_batch(pad(np.array(data[1::2],order='C'),ne,n),u,64)
dxchange.write_tiff_stack(
ucg[:,ne//2-n//2:ne//2+n//2,ne//2-n//2:ne//2+n//2], name+'/cgn_resolution2_'+'_'+str(ntheta//2)+'/rect'+str(k)+'/r', overwrite=True)
import signal
import sys
import cupy as cp
import dxchange
import numpy as np
import tomocg as pt
if __name__ == "__main__":
# Model parameters
n = 128 # object size n x,y
nz = 128 # object size in z
ntheta = 128 # number of angles (rotations)
center = n / 2 # rotation center
theta = np.linspace(0, np.pi, ntheta).astype('float32') # angles
niter = 64 # tomography iterations
pnz = 32 # number of slice partitions for simultaneous processing in tomography
# Load object
beta = dxchange.read_tiff('data/beta-chip-128.tiff')
delta = dxchange.read_tiff('data/delta-chip-128.tiff')
u0 = delta + 1j * beta
# Class gpu solver
with pt.SolverTomo(theta, ntheta, nz, n, pnz, center) as slv:
# generate data
data = slv.fwd_tomo_batch(u0)
# adjoint test
u1 = slv.adj_tomo_batch(data)
print('Adjoint test: ', np.sum(data * np.conj(data)), '=?',
np.sum(u0 * np.conj(u1)))
data = np.load('prj'+name+'_'+part+'.npy').astype('float32')
theta = np.load('theta'+name+'_'+part+'.npy').astype('float32')
[ntheta,nz,n] = data.shape
pnz = 128 # number of slice partitions for simultaneous processing in tomography
niter = 128
alpha = 1.0e-7
# initial guess
u = np.zeros([nz, n, n], dtype='complex64')
psi1 = data.copy()
lamd1 = np.zeros([ntheta, nz, n], dtype='complex64')
psi2 = np.zeros([3, nz, n, n], dtype='complex64')
lamd2 = np.zeros([3, nz, n, n], dtype='complex64')
flow = np.zeros([ntheta, 2], dtype='float32')
with tc.SolverTomo(theta, ntheta, nz, n, pnz, center) as tslv:
with dc.SolverDeform(ntheta, nz, n) as dslv:
rho1 = 0.5
rho2 = 0.5
h01 = psi1
h02 = psi2
for k in range(niter):
# registration
flow = dslv.registration_shift_batch(psi1, data, 100)
# deformation subproblem
#psi1 = dslv.cg_shift(data, psi1, flow, 4,
# tslv.fwd_tomo_batch(u)+lamd1/rho1, rho1)
psi1 = (dslv.apply_shift_batch(data, -flow) +
rho1*tslv.fwd_tomo_batch(u)+lamd1)/(1+rho1)
# regularization subproblem
psi2 = tslv.solve_reg(u,lamd2,rho2,alpha)
2, binning
) # number of slice partitions for simultaneous processing in tomography
ptheta = 40
dxchange.write_tiff_stack(data, name + '/data/d', overwrite=True)
#exit()
#if(il==0):
u = np.zeros([nz, ne, ne], dtype='float32')
psi = data.copy() * 0
lamd = np.zeros([ntheta, nz, n], dtype='float32')
flow = np.zeros([ntheta, nz, n, 2], dtype='float32')
#else:
# u, psi, lamd, flow = interpdense(u,psi,lamd,flow)
# optical flow parameters
pars = [0.5, 1, w[il], 4, 5, 1.1, 4]
with tc.SolverTomo(theta, ntheta, nz, ne, pnz,
center / pow(2, binning), ngpus) as tslv:
with dc.SolverDeform(ntheta, nz, n, ptheta) as dslv:
rho = 0.5
h0 = psi
for k in range(niter[il]):
# registration
# print(np.linalg.norm(psi-data))
tic()
flow = dslv.registration_flow_batch(
psi, data, mmin, mmax, flow.copy(), pars, 40)
print(toc())
# Tpsi = dslv.apply_flow_gpu_batch(psi, flow)
# print(np.linalg.norm(Tpsi-data))
# deformation subproblem
tic()
if (r > 10 * s):
rho *= 2
elif (s > 10 * r):
rho *= 0.5
return rho
if __name__ == "__main__":
name = sys.argv[1]
part = sys.argv[2]
#center = np.float(sys.argv[3])
data = np.load('prj' + name + '_' + part + '.npy').astype('float32')
theta = np.load('theta' + name + '_' + part + '.npy').astype('float32')
# Model parameters
[ntheta, nz, n] = data.shape
data = data[:, nz // 2:nz // 2 + 2]
# initial guess
u = np.zeros([1, n, n], dtype='complex64')
print(data.shape)
print(theta)
print(np.linalg.norm(data))
for center in range(n // 2 - 10, n // 2 + 10):
print(center)
with tc.SolverTomo(theta, ntheta, 1, n, 1, center) as tslv:
ucg = tslv.cg_tomo_batch(data, u, 64)
dxchange.write_tiff_stack(ucg.real,
'cg' + '_' + name + '_' + part + '/r' +
str(center),
overwrite=True)
