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 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 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