def update_plot(iteration, image, fourier, error, support, intensities):
errs.append(error)
if not len(figs):
plt.ion()
fig = plt.figure(figsize=(6.5,10))
ax5 = plt.subplot(313)
ax1 = plt.subplot(321)
ax2 = plt.subplot(322)
ax3 = plt.subplot(323)
ax4 = plt.subplot(324)
figs.append(fig)
[axes.append(ax) for ax in [ax1,ax2,ax3,ax4,ax5]]
for i in range(4):
axes[i].set_yticklabels([])
axes[i].set_xticklabels([])
axes[i].set_yticks([])
axes[i].set_xticks([])
#plt.tight_layout()
ims.append(ax1.imshow(np.abs(image)))
ims.append(ax2.imshow(np.abs(image)*support))
ims.append(ax3.imshow(np.abs(fourier)**2, norm=LogNorm()))
ims.append(ax4.imshow(intensities, norm=LogNorm()))
l, = ax5.plot(errs)
line.append(l)
ax5.semilogy()
figs.append(fig.suptitle('Iteration %d' %iteration))
fig.set_tight_layout(True)
else:
figs[1].set_text('Iteration %d' %iteration)
ims[0].set_data(np.abs(image))
ims[0].set_clim([np.abs(image).min(), np.abs(image).max()])
ims[1].set_data(np.abs(image)*support)
ims[1].set_clim([np.abs(image).min(), np.abs(image).max()])
ims[2].set_data(np.abs(fourier)**2)
ims[3].set_data(intensities)
line[0].set_xdata(range(iteration+1))
line[0].set_ydata(errs)
axes[4].set_xlim([0,iteration+1])
axes[4].set_ylim([min(errs), max(errs)])
plt.draw()
def update_plot(iteration, image, fourier, error, support, intensities):
errs.append(error)
if not len(figs):
plt.ion()
fig = plt.figure(figsize=(6.5, 10))
ax5 = plt.subplot(313)
ax1 = plt.subplot(321)
ax2 = plt.subplot(322)
ax3 = plt.subplot(323)
ax4 = plt.subplot(324)
figs.append(fig)
[axes.append(ax) for ax in [ax1, ax2, ax3, ax4, ax5]]
for i in range(4):
axes[i].set_yticklabels([])
axes[i].set_xticklabels([])
axes[i].set_yticks([])
axes[i].set_xticks([])
#plt.tight_layout()
ims.append(ax1.imshow(np.abs(image)))
ims.append(ax2.imshow(np.abs(image) * support))
ims.append(ax3.imshow(np.abs(fourier)**2, norm=LogNorm()))
ims.append(ax4.imshow(intensities, norm=LogNorm()))
l, = ax5.plot(errs)
line.append(l)
ax5.semilogy()
figs.append(fig.suptitle('Iteration %d' % iteration))
fig.set_tight_layout(True)
else:
figs[1].set_text('Iteration %d' % iteration)
ims[0].set_data(np.abs(image))
ims[0].set_clim([np.abs(image).min(), np.abs(image).max()])
ims[1].set_data(np.abs(image) * support)
ims[1].set_clim([np.abs(image).min(), np.abs(image).max()])
ims[2].set_data(np.abs(fourier)**2)
ims[3].set_data(intensities)
line[0].set_xdata(range(iteration + 1))
line[0].set_ydata(errs)
axes[4].set_xlim([0, iteration + 1])
axes[4].set_ylim([min(errs), max(errs)])
plt.draw()
def update_plot(iteration, image, phase, error, support, intensities):
if not len(figs):
plt.ion()
fig = plt.figure(figsize=(7,10))
ax5 = plt.subplot(313)
ax1 = plt.subplot(321)
ax2 = plt.subplot(322)
ax3 = plt.subplot(323)
ax4 = plt.subplot(324)
plt.subplots_adjust(wspace=0.05, hspace=0.05)
figs.append(fig)
[axes.append(ax) for ax in [ax1,ax2,ax3,ax4,ax5]]
for i in range(4):
axes[i].set_yticklabels([])
axes[i].set_xticklabels([])
axes[i].set_yticks([])
axes[i].set_xticks([])
#plt.tight_layout()
ims.append(ax1.imshow(np.abs(image)))
ims.append(ax2.imshow(np.abs(image)*support))
ims.append(ax3.imshow(phase, vmin=-np.pi, vmax=np.pi))
ims.append(ax4.imshow(intensities, norm=LogNorm()))
l, = ax5.plot(error)
line.append(l)
ax5.semilogy()
text.append(axes[4].text(0.5, 0.9, 'Iteration = %d' %iteration, transform=axes[4].transAxes, va='center', ha='center'))
#figs.append(fig.suptitle('Iteration %d' %iteration))
else:
#figs[1].set_text('Iteration %d' %iteration)
ims[0].set_data(np.abs(image))
ims[0].set_clim([np.abs(image).min(), np.abs(image).max()])
ims[1].set_data(np.abs(image)*support)
ims[1].set_clim([np.abs(image).min(), np.abs(image).max()])
ims[2].set_data(phase[::2,::2])
ims[2].set_clim([-np.pi, np.pi])
ims[3].set_data(intensities)
ims[3].set_clim([intensities.min(), intensities.max()])
line[0].set_xdata(range(iteration+1))
line[0].set_ydata(error)
axes[4].set_xlim([0,iteration+1])
axes[4].set_ylim([0.001, 0.1])
text[0].set_text('Iteration = %d' %iteration)
plt.draw()
def test_abs():
b = numpy.random.random((2, 3))
a = afnumpy.array(b)
fassert(afnumpy.abs(a), numpy.abs(b))
def norm(x, ord=None, axis=None, keepdims=False):
x = asarray(x)
# Check the default case first and handle it immediately.
if ord is None and axis is None:
ndim = x.ndim
x = x.ravel(order='K')
if isComplexType(x.dtype.type):
sqnorm = dot(x.real, x.real) + dot(x.imag, x.imag)
else:
sqnorm = dot(x, x)
ret = sqrt(sqnorm)
if keepdims:
ret = ret.reshape(ndim*[1])
return ret
# Normalize the `axis` argument to a tuple.
nd = x.ndim
if axis is None:
axis = tuple(range(nd))
elif not isinstance(axis, tuple):
try:
axis = int(axis)
except:
raise TypeError("'axis' must be None, an integer or a tuple of integers")
axis = (axis,)
if len(axis) == 1:
if ord == Inf:
return abs(x).max(axis=axis, keepdims=keepdims)
elif ord == -Inf:
return abs(x).min(axis=axis, keepdims=keepdims)
elif ord == 0:
# Zero norm
return (x != 0).sum(axis=axis, keepdims=keepdims)
elif ord == 1:
# special case for speedup
return afnumpy.sum(abs(x), axis=axis, keepdims=keepdims)
elif ord is None or ord == 2:
# special case for speedup
s = (x.conj() * x).real
return sqrt(afnumpy.sum(s, axis=axis, keepdims=keepdims))
else:
try:
ord + 1
except TypeError:
raise ValueError("Invalid norm order for vectors.")
if x.dtype.type is longdouble:
# Convert to a float type, so integer arrays give
# float results. Don't apply asfarray to longdouble arrays,
# because it will downcast to float64.
absx = abs(x)
else:
absx = x if isComplexType(x.dtype.type) else asfarray(x)
if absx.dtype is x.dtype:
absx = abs(absx)
else:
# if the type changed, we can safely overwrite absx
abs(absx, out=absx)
absx **= ord
return afnumpy.sum(absx, axis=axis, keepdims=keepdims) ** (1.0 / ord)
elif len(axis) == 2:
row_axis, col_axis = axis
if not (-nd <= row_axis < nd and -nd <= col_axis < nd):
raise ValueError('Invalid axis %r for an array with shape %r' %
(axis, x.shape))
if row_axis % nd == col_axis % nd:
raise ValueError('Duplicate axes given.')
if ord == 2:
ret = _multi_svd_norm(x, row_axis, col_axis, amax)
elif ord == -2:
ret = _multi_svd_norm(x, row_axis, col_axis, amin)
elif ord == 1:
if col_axis > row_axis:
col_axis -= 1
ret = afnumpy.sum(abs(x), axis=row_axis).max(axis=col_axis)
elif ord == Inf:
if row_axis > col_axis:
row_axis -= 1
ret = afnumpy.sum(abs(x), axis=col_axis).max(axis=row_axis)
elif ord == -1:
if col_axis > row_axis:
col_axis -= 1
ret = afnumpy.sum(abs(x), axis=row_axis).min(axis=col_axis)
elif ord == -Inf:
if row_axis > col_axis:
row_axis -= 1
ret = afnumpy.sum(abs(x), axis=col_axis).min(axis=row_axis)
elif ord in [None, 'fro', 'f']:
ret = sqrt(afnumpy.sum((x.conj() * x).real, axis=axis))
else:
raise ValueError("Invalid norm order for matrices.")
if keepdims:
ret_shape = list(x.shape)
ret_shape[axis[0]] = 1
ret_shape[axis[1]] = 1
ret = ret.reshape(ret_shape)
return ret
else:
raise ValueError("Improper number of dimensions to norm.")
def get_error(fourier, intensities):
return np.abs((np.sqrt(intensities) - np.abs(fourier)).sum()) / np.sqrt(intensities).sum()
def data_constraint(fourier, intensities):
return (fourier / np.abs(fourier)) * np.sqrt(intensities)
# Forward propagation
fourier = fft.fftn(image)
# Check convergence
error.append(get_error(fourier, intensities))
#error = 0
print "Iteration: %d, error: %f" %(i, error[-1])
# Update plot
if (not i%10):
update_plot(i, image[200:-200,200:-200], np.angle(fourier), error, support[200:-200,200:-200], intensities)
# Apply data constraint
#fourier = data_constraint(fourier, intensities)
fourier /= np.abs(fourier)
fourier *= np.sqrt(intensities)
# Backward propagation
image = fft.ifftn(fourier)
# Apply support constraint
image *= support
#image = support_constraint(image, support)
# Timing
t1 = time.time() - t0
print "%d Iterations took %2.f seconds (%.2f iterations per second) using %s" %(nr_iterations, t1, float(nr_iterations)/t1, use)
update_plot(i, image[200:-200, 200:-200], np.angle(fourier), error, support[200:-200,200:-200], intensities)
def data_constraint(fourier, intensities):
return (fourier / np.abs(fourier)) * np.sqrt(intensities)
def Pmod_single(amp, O, mask = 1, alpha = 1.0e-10):
out = mask * O * amp / (afnumpy.abs(O) + alpha)
out += (1 - mask) * O
return out
def test_abs():
b = numpy.random.random((2,3))
a = afnumpy.array(b)
fassert(afnumpy.abs(a), numpy.abs(b))
data_fourier = np.array(f['entry_1/data_1/data_fourier'][0]).astype(np.complex64)
# True image
true_image = fft.fftshift(fft.ifftn(data_fourier))
#import arrayfire
#print arrayfire.backend.name
#print type(true_image)
#print true_image.dtype
#print intensities.dtype
#print data_fourier.dtype
# Initial image
image = 1j + np.random.random(intensities.shape)
# Define support
support = np.abs(true_image)>1
# Define Nr. of iterations
nr_iterations = 2000
# Define data constraint
def data_constraint(fourier, intensities):
return (fourier / np.abs(fourier)) * np.sqrt(intensities)
# Define support constraint
def support_constraint(img, support):
img = img.flatten()
img[support == 0] = 0
#img *= support
return img.reshape((256,256))
#return img
def get_error(fourier, intensities):
return np.abs((np.sqrt(intensities) -
np.abs(fourier)).sum()) / np.sqrt(intensities).sum()
def gpuSIRT(tomo, angles, center, input_params):
print('Starting GPU SIRT recon')
#allocate space for final answer
af.set_device(
input_params['gpu_device']) #Set the device number for gpu based code
#Change tomopy format
new_tomo = np.transpose(tomo, (1, 2, 0)) #slice, columns, angles
im_size = new_tomo.shape[1]
num_slice = new_tomo.shape[0]
num_angles = new_tomo.shape[2]
pad_size = np.int16(im_size * input_params['oversamp_factor'])
nufft_scaling = (np.pi / pad_size)**2
num_iter = input_params['num_iter']
#Initialize structures for NUFFT
sino = {}
geom = {}
sino['Ns'] = pad_size #Sinogram size after padding
sino['Ns_orig'] = im_size #size of original sinogram
sino['center'] = center + (sino['Ns'] / 2 - sino['Ns_orig'] / 2
) #for padded sinogram
sino['angles'] = angles
#Initialize NUFFT parameters
nufft_params = init_nufft_params(sino, geom)
temp_y = afnp.zeros((sino['Ns'], num_angles), dtype=afnp.complex64)
temp_x = afnp.zeros((sino['Ns'], sino['Ns']), dtype=afnp.complex64)
x_recon = afnp.zeros((num_slice / 2, sino['Ns_orig'], sino['Ns_orig']),
dtype=afnp.complex64)
pad_idx = slice(sino['Ns'] / 2 - sino['Ns_orig'] / 2,
sino['Ns'] / 2 + sino['Ns_orig'] / 2)
#allocate output array
rec_sirt_final = np.zeros((num_slice, sino['Ns_orig'], sino['Ns_orig']),
dtype=np.float32)
#Pre-compute diagonal scaling matrices ; one the same size as the image and the other the same as data
#initialize an image of all ones
x_ones = afnp.ones((sino['Ns_orig'], sino['Ns_orig']),
dtype=afnp.complex64)
temp_x[pad_idx, pad_idx] = x_ones
temp_proj = forward_project(temp_x,
nufft_params) * (sino['Ns'] * afnp.pi / 2)
R = 1 / afnp.abs(temp_proj)
R[afnp.isnan(R)] = 0
R[afnp.isinf(R)] = 0
R = afnp.array(R, dtype=afnp.complex64)
#Initialize a sinogram of all ones
y_ones = afnp.ones((sino['Ns_orig'], num_angles), dtype=afnp.complex64)
temp_y[pad_idx] = y_ones
temp_backproj = back_project(temp_y, nufft_params) * nufft_scaling / 2
C = 1 / (afnp.abs(temp_backproj))
C[afnp.isnan(C)] = 0
C[afnp.isinf(C)] = 0
C = afnp.array(C, dtype=afnp.complex64)
#Move all data to GPU
slice_1 = slice(0, num_slice, 2)
slice_2 = slice(1, num_slice, 2)
gdata = afnp.array(new_tomo[slice_1] + 1j * new_tomo[slice_2],
dtype=afnp.complex64)
#loop over all slices
for i in range(num_slice / 2):
for iter_num in range(num_iter):
#filtered back-projection
temp_x[pad_idx, pad_idx] = x_recon[i]
Ax = (np.pi / 2) * sino['Ns'] * forward_project(
temp_x, nufft_params)
temp_y[pad_idx] = gdata[i]
x_recon[i] = x_recon[i] + (
C * back_project(R * (temp_y - Ax), nufft_params) *
nufft_scaling / 2)[pad_idx, pad_idx]
#Move to CPU
#Rescale result to match tomopy
rec_sirt = np.array(x_recon, dtype=np.complex64)
rec_sirt_final[slice_1] = np.array(rec_sirt.real, dtype=np.float32)
rec_sirt_final[slice_2] = np.array(rec_sirt.imag, dtype=np.float32)
return rec_sirt_final
def norm(x, ord=None, axis=None, keepdims=False):
x = asarray(x)
# Check the default case first and handle it immediately.
if ord is None and axis is None:
ndim = x.ndim
x = x.ravel(order='K')
if isComplexType(x.dtype.type):
sqnorm = dot(x.real, x.real) + dot(x.imag, x.imag)
else:
sqnorm = dot(x, x)
ret = sqrt(sqnorm)
if keepdims:
ret = ret.reshape(ndim * [1])
return ret
# Normalize the `axis` argument to a tuple.
nd = x.ndim
if axis is None:
axis = tuple(range(nd))
elif not isinstance(axis, tuple):
try:
axis = int(axis)
except:
raise TypeError(
"'axis' must be None, an integer or a tuple of integers")
axis = (axis, )
if len(axis) == 1:
if ord == Inf:
return abs(x).max(axis=axis, keepdims=keepdims)
elif ord == -Inf:
return abs(x).min(axis=axis, keepdims=keepdims)
elif ord == 0:
# Zero norm
return (x != 0).sum(axis=axis, keepdims=keepdims)
elif ord == 1:
# special case for speedup
return afnumpy.sum(abs(x), axis=axis, keepdims=keepdims)
elif ord is None or ord == 2:
# special case for speedup
s = (x.conj() * x).real
return sqrt(afnumpy.sum(s, axis=axis, keepdims=keepdims))
else:
try:
ord + 1
except TypeError:
raise ValueError("Invalid norm order for vectors.")
if x.dtype.type is longdouble:
# Convert to a float type, so integer arrays give
# float results. Don't apply asfarray to longdouble arrays,
# because it will downcast to float64.
absx = abs(x)
else:
absx = x if isComplexType(x.dtype.type) else asfarray(x)
if absx.dtype is x.dtype:
absx = abs(absx)
else:
# if the type changed, we can safely overwrite absx
abs(absx, out=absx)
absx **= ord
return afnumpy.sum(absx, axis=axis, keepdims=keepdims)**(1.0 / ord)
elif len(axis) == 2:
row_axis, col_axis = axis
if not (-nd <= row_axis < nd and -nd <= col_axis < nd):
raise ValueError('Invalid axis %r for an array with shape %r' %
(axis, x.shape))
if row_axis % nd == col_axis % nd:
raise ValueError('Duplicate axes given.')
if ord == 2:
ret = _multi_svd_norm(x, row_axis, col_axis, amax)
elif ord == -2:
ret = _multi_svd_norm(x, row_axis, col_axis, amin)
elif ord == 1:
if col_axis > row_axis:
col_axis -= 1
ret = afnumpy.sum(abs(x), axis=row_axis).max(axis=col_axis)
elif ord == Inf:
if row_axis > col_axis:
row_axis -= 1
ret = afnumpy.sum(abs(x), axis=col_axis).max(axis=row_axis)
elif ord == -1:
if col_axis > row_axis:
col_axis -= 1
ret = afnumpy.sum(abs(x), axis=row_axis).min(axis=col_axis)
elif ord == -Inf:
if row_axis > col_axis:
row_axis -= 1
ret = afnumpy.sum(abs(x), axis=col_axis).min(axis=row_axis)
elif ord in [None, 'fro', 'f']:
ret = sqrt(afnumpy.sum((x.conj() * x).real, axis=axis))
else:
raise ValueError("Invalid norm order for matrices.")
if keepdims:
ret_shape = list(x.shape)
ret_shape[axis[0]] = 1
ret_shape[axis[1]] = 1
ret = ret.reshape(ret_shape)
return ret
else:
raise ValueError("Improper number of dimensions to norm.")
def Pmod_single(amp, O, mask=1, alpha=1.0e-10):
out = mask * O * amp / (afnumpy.abs(O) + alpha)
out += (1 - mask) * O
return out
np.complex64)
# True image
true_image = fft.fftshift(fft.ifftn(data_fourier))
#import arrayfire
#print arrayfire.backend.name
#print type(true_image)
#print true_image.dtype
#print intensities.dtype
#print data_fourier.dtype
# Initial image
image = 1j + np.random.random(intensities.shape)
# Define support
support = np.abs(true_image) > 1
# Define Nr. of iterations
nr_iterations = 2000
# Define data constraint
def data_constraint(fourier, intensities):
return (fourier / np.abs(fourier)) * np.sqrt(intensities)
# Define support constraint
def support_constraint(img, support):
img = img.flatten()
img[support == 0] = 0
#img *= support
