def __init__(self, I, **args): modes = Modes() # check if there is a background if isValid('background', args): if args['background'] is True : modes['B'] = np.random.random((I.shape)).astype(args['dtype']) else : modes['B'] = np.sqrt(args['background']).astype(args['dtype']) modes['B'] = afnumpy.array(modes['B']) if isValid('O', args): modes['O'] = args['O'] else : modes['O'] = np.random.random(I.shape).astype(args['c_dtype']) modes['O'] = afnumpy.array(modes['O']) # this is the radial value for every pixel # in the volume self.rs = None self.mask = 1 if isValid('mask', args): self.mask = args['mask'] if args['mask'] is not 1 : self.mask = afnumpy.array(self.mask) self.alpha = 1.0e-10 if isValid('alpha', args): self.alpha = args['alpha'] if isValid('mask', args) : self.I_norm = (args['mask'] * I).sum() else : self.I_norm = I.sum() self.amp = afnumpy.sqrt(afnumpy.array(I.astype(args['dtype']))) # define the data projection # -------------------------- if 'B' in modes.keys() : self.Pmod = self.Pmod_back else : self.Pmod = self.Pmod_single # define the support projection # ----------------------------- if isValid('voxel_number', args) : self.voxel_number = args['voxel_number'] else : self.voxel_number = False self.S = afnumpy.array(args['support']) self.support = None if isValid('support', args): self.support = afnumpy.array(args['support']) self.modes = modes
def __init__(self, I, **args): modes = Modes() # check if there is a background if isValid('background', args): if args['background'] is True: modes['B'] = np.random.random((I.shape)).astype(args['dtype']) else: modes['B'] = np.sqrt(args['background']).astype(args['dtype']) modes['B'] = afnumpy.array(modes['B']) if isValid('O', args): modes['O'] = args['O'] else: modes['O'] = np.random.random(I.shape).astype(args['c_dtype']) modes['O'] = afnumpy.array(modes['O']) # this is the radial value for every pixel # in the volume self.rs = None self.mask = 1 if isValid('mask', args): self.mask = args['mask'] if args['mask'] is not 1: self.mask = afnumpy.array(self.mask) self.alpha = 1.0e-10 if isValid('alpha', args): self.alpha = args['alpha'] if isValid('mask', args): self.I_norm = (args['mask'] * I).sum() else: self.I_norm = I.sum() self.amp = afnumpy.sqrt(afnumpy.array(I.astype(args['dtype']))) # define the data projection # -------------------------- if 'B' in list(modes.keys()): self.Pmod = self.Pmod_back else: self.Pmod = self.Pmod_single # define the support projection # ----------------------------- if isValid('voxel_number', args): self.voxel_number = args['voxel_number'] else: self.voxel_number = False self.S = afnumpy.array(args['support']) self.support = None if isValid('support', args): self.support = afnumpy.array(args['support']) self.modes = modes
def Emod(self, modes): M = self.Imap(modes) eMod = afnumpy.sum(self.mask * (afnumpy.sqrt(M) - self.amp)**2) eMod = afnumpy.sqrt(eMod / self.I_norm) return eMod
def constructTestWaveField(npoints=256,ekeV=0.6,z1=5, show=False): # Simple function for generating simple Gaussian wavefield for testing purposes from wpg.srwlib import srwl_uti_ph_en_conv from extensions.gvrutils import calculate_theta_fwhm_cdr from wpg.generators import build_gauss_wavefront_xy # set wavefield parameters qnC = 0.01 wlambda = srwl_uti_ph_en_conv(ekeV, _in_u='keV', _out_u='nm') theta_fwhm = calculate_theta_fwhm_cdr(ekeV,qnC) k = 2*np.sqrt(2*np.log(2)) range_xy = (theta_fwhm/k*z1*5.)*2.0 sigX = 12.4e-10*k/(ekeV*4*np.pi*theta_fwhm) # construct wavefield wf0=build_gauss_wavefront_xy(nx=npoints, ny=npoints, ekev=ekeV, xMin=-range_xy/2 ,xMax=range_xy/2, yMin=-range_xy/2, yMax=range_xy/2, sigX=sigX, sigY=sigX, d2waist=z1, _mx=0, _my=0 ) wfr = Wavefront(srwl_wavefront=wf0) print('Wavelength=%f, theta FWWM=%f, range XY = %f, sig X = %f' % (wlambda, theta_fwhm, range_xy, sigX)) wfr._srwl_wf.unitElFld = 1#'sqrt(Phot/s/0.1%bw/mm^2)' if show==True: #display the wavefield plotWavefront(wfr, 'Wavefield at source') return wfr def generate_mode_test(self, mode_no, eigenfn, outdir, gwaist = None): gauss_0 = primary_gaussian() # properties of gaussian gauss_0.d2waist = -9.0000 if gwaist is not None: gauss_0.d2waist = gwaist print("Generating Mode {}".format(mode_no)) _mx = eigenfn[mode_no][0] _my = eigenfn[mode_no][1] M2x = (2*_mx)+1 M2y = (2*_my)+1 GsnBm = SRWLGsnBm(_x = 0, _y = 0, _z = 0, _sigX = 100e-06,#gauss_0.sigX*(M2x**-0.25), _sigY = 100e-06,#gauss_0.sigY*(M2y**-0.25), _xp = 0, #gauss_0.xp, _yp = 0,#gauss_0.yp, _mx = _mx, _my = _my, _avgPhotEn = gauss_0.E) wfr = Wavefront(build_gaussian(GsnBm, gauss_0.nx*2, gauss_0.ny*2, gauss_0.xMin*2, gauss_0.xMax*2, gauss_0.yMin*2, gauss_0.yMax*2)) wfr.store_hdf5(outdir + "wfr_mode_{}.hdf5".format(mode_no)) return wfr
def test_sqrt(): a = afnumpy.random.random((2, 3)) b = numpy.array(a) fassert(afnumpy.sqrt(a), numpy.sqrt(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)
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_back(amp, background, O, mask = 1, alpha = 1.0e-10): M = mask * amp / afnumpy.sqrt((O.conj() * O).real + background**2 + alpha) out = O * M background *= M out += (1 - mask) * O return out, background
def Emod(self, modes): M = self.Imap(modes) eMod = afnumpy.sum( self.mask * ( afnumpy.sqrt(M) - self.amp )**2 ) eMod = afnumpy.sqrt( eMod / self.I_norm ) return eMod
def test_sqrt(): a = afnumpy.random.random((2,3)) b = numpy.array(a) fassert(afnumpy.sqrt(a), numpy.sqrt(b))
t0 = time.time() # Start the reconstruction (using ER) for i in range(nr_iterations): # Forward propagation fourier = fft.fftn(image) # Check convergence #error = get_error(fourier, intensities) #print "Iteration: %d, error: %f" %(i, error) #print i # Update plot #update_plot(i, image, fourier, error, support, 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 print "%d Iterations took %d seconds using %s" %(nr_iterations, time.time() - t0, use)
def Pmod_back(amp, background, O, mask=1, alpha=1.0e-10): M = mask * amp / afnumpy.sqrt((O.conj() * O).real + background**2 + alpha) out = O * M background *= M out += (1 - mask) * O return out, background
# 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)).astype(np.complex64) # Define support yy,xx = np.meshgrid(np.arange(image.shape[0]), np.arange(image.shape[1])) rr = np.sqrt((xx-image.shape[1]/2)**2 + (yy-image.shape[0]/2)**2) support = rr < 24 #support = np.abs(true_image)>1 # Define Nr. of iterations nr_iterations = 500 # 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
# Start the reconstruction (using ER) for i in range(nr_iterations): # Forward propagation fourier = fft.fftn(image) # Check convergence #error = get_error(fourier, intensities) #print "Iteration: %d, error: %f" %(i, error) #print i # Update plot #update_plot(i, image, fourier, error, support, 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 print "%d Iterations took %d seconds using %s" % (nr_iterations, time.time() - t0, use)