def __init__(self, u,v,k, lamb = 488, n=1.51, field_x=0, field_y=0, apertureNA=1.5, apertureZGradient = 0):
#print k**2
#m = (u**2 + v**2) <= (n/lamb**2)
#self.propFac = fftw3f.create_aligned_array(u.shape, 'complex64')
#self.propFac = 1j*8*pi*sqrt(np.maximum((n/lamb)**2 - (u**2 + v**2), 0))
#self.propFac = ((2*pi*n/lamb)*sqrt(np.maximum(1 - (u**2 + v**2), 0))).astype('f')
self.propFac = ((2*pi*n/lamb)*cos(.5*pi*sqrt((u**2 + v**2)))).astype('f')
self.pfm =(self.propFac > 0).astype('f')
#self.field_x = field_x
#self.field_y = field_y
self.appR = apertureNA/n
self.apertureZGrad = apertureZGradient
self.x = u - field_x
self.y = v - field_y
self._F = fftw3f.create_aligned_array(u.shape, 'complex64')
self._f = fftw3f.create_aligned_array(u.shape, 'complex64')
#print('Creating plans for FFTs - this might take a while')
#calculate plans for other ffts
self._plan_f_F = fftw3f.Plan(self._f, self._F, 'forward', flags = FFTWFLAGS, nthreads=NTHREADS)
self._plan_F_f = fftw3f.Plan(self._F, self._f, 'backward', flags = FFTWFLAGS, nthreads=NTHREADS)
#self._plan_F_f = fftw3f.Plan(self._F, self._f, 'backward', flags = FFTWFLAGS, nthreads=NTHREADS)
fftwWisdom.save_wisdom()
def __init__(self, ps, vox, PSSize):
ps = ps.max(2)
ps = ps - ps.min()
ps = ps*scipy.signal.hanning(ps.shape[0])[:,None]*scipy.signal.hanning(ps.shape[1])[None,:]
ps = ps/ps.sum()
#PSFFileName = PSFFilename
pw = (numpy.array(PSSize) - ps.shape)/2.
pw1 = numpy.floor(pw)
pw2 = numpy.ceil(pw)
self.cachedPSF = pad.with_constant(ps, ((pw2[0], pw1[0]), (pw2[1], pw1[1])), (0,))
self.cachedOTFH = (ifftn(self.cachedPSF)*self.cachedPSF.size).astype('complex64')
self.cachedOTF2 = (self.cachedOTFH*fftn(self.cachedPSF)).astype('complex64')
self.weinerFT = fftw3.create_aligned_array(self.cachedOTFH.shape, 'complex64')
self.weinerR = fftw3.create_aligned_array(self.cachedOTFH.shape, 'float32')
self.planForward = fftw3.Plan(self.weinerR, self.weinerFT, flags = FFTWFLAGS, nthreads=NTHREADS)
self.planInverse = fftw3.Plan(self.weinerFT, self.weinerR, direction='reverse', flags = FFTWFLAGS, nthreads=NTHREADS)
fftwWisdom.save_wisdom()
self.otf2mean = self.cachedOTF2.mean()
def __init__(self, u, v, k=None, lamb=488, n=1.51):
"""A FourierPropagator object allows us evaluate the electric field at a given defocus by propagating a complex
pupil distribution a given distance from the nominal focus by adding the relevant phase term to the pupil and
then taking the Fourier amplitude.
Parameters
==========
u, v : 2d arrays of float
the co-ordinates in spatial frequencies within the pupil plane
lamb : float
the wavelength in nm
n : float
the refractive index of the media
Notes
=====
u, v must be the same size as the eventual pupil distribution to be used. On creation, the FourierPropagator
pre-calculates the phase factor to add for each u, v, co-ordinate and also pre-computes FFTW3 plans for the
necessary Fourier transforms.
"""
if not k is None:
raise DeprecationWarning('k is no longer used')
#R = np.sqrt(u**2 + v**2)
self.propFac = ((2 * np.pi * n / lamb) *
np.sqrt(1 - np.minimum(u**2 + v**2, 1))).astype('f')
#self.pfm =(self.propFac > 0).astype('f')
self.pfm = (np.sqrt(u**2 + v**2) < 1).astype('f')
self._F = fftw3f.create_aligned_array(u.shape, 'complex64')
self._f = fftw3f.create_aligned_array(u.shape, 'complex64')
#print('Creating plans for FFTs - this might take a while')
#calculate plans for other ffts
self._plan_f_F = fftw3f.Plan(self._f,
self._F,
'forward',
flags=FFTWFLAGS,
nthreads=NTHREADS)
self._plan_F_f = fftw3f.Plan(self._F,
self._f,
'backward',
flags=FFTWFLAGS,
nthreads=NTHREADS)
#self._plan_F_f = fftw3f.Plan(self._F, self._f, 'backward', flags = FFTWFLAGS, nthreads=NTHREADS)
fftwWisdom.save_wisdom()
def __init__(self, ps, vox, PSSize):
ps = ps.max(2)
ps = ps - ps.min()
ps = ps * scipy.signal.hanning(
ps.shape[0])[:, None] * scipy.signal.hanning(ps.shape[1])[None, :]
ps = ps / ps.sum()
#PSFFileName = PSFFilename
pw = (numpy.array(PSSize) - ps.shape) / 2.
pw1 = numpy.floor(pw)
pw2 = numpy.ceil(pw)
self.cachedPSF = pad.with_constant(ps, ((pw2[0], pw1[0]),
(pw2[1], pw1[1])), (0, ))
self.cachedOTFH = (ifftn(self.cachedPSF) *
self.cachedPSF.size).astype('complex64')
self.cachedOTF2 = (self.cachedOTFH *
fftn(self.cachedPSF)).astype('complex64')
self.weinerFT = fftw3.create_aligned_array(self.cachedOTFH.shape,
'complex64')
self.weinerR = fftw3.create_aligned_array(self.cachedOTFH.shape,
'float32')
self.planForward = fftw3.Plan(self.weinerR,
self.weinerFT,
flags=FFTWFLAGS,
nthreads=NTHREADS)
self.planInverse = fftw3.Plan(self.weinerFT,
self.weinerR,
direction='reverse',
flags=FFTWFLAGS,
nthreads=NTHREADS)
fftwWisdom.save_wisdom()
self.otf2mean = self.cachedOTF2.mean()
