def Shrinkwrap(self, sigma, thresh):
dist = tf.contrib.distributions.MultivariateNormalDiag(
[0., 0., 0.], [sigma, sigma, sigma])
kernelFFT = tf.fft3d(
tf.cast(tf.reshape(dist.prob(self._domain), self._probSize),
tf.complex64))
blurred = tf.abs(
tf.ifft3d(
tf.multiply(
tf.fft3d(tf.cast(tf.abs(self._cImage), tf.complex64)),
kernelFFT)))
blurred = tf.concat((blurred[(self._probSize[0] // 2):, :, :],
blurred[:(self._probSize[0] // 2), :, :]),
axis=0)
blurred = tf.concat((blurred[:, (self._probSize[1] // 2):, :],
blurred[:, :(self._probSize[1] // 2), :]),
axis=1)
blurred = tf.concat((blurred[:, :, (self._probSize[2] // 2):],
blurred[:, :, :(self._probSize[2] // 2)]),
axis=2)
self._support = tf.cast(blurred > thresh * tf.reduce_max(blurred),
tf.complex64)
self._support_comp = tf.cast(
blurred <= thresh * tf.reduce_max(blurred), tf.complex64)
return
def get_highPass(img, mode='gradient', paras={}):
if mode == 'gradient':
imgY, imgX = tf.image.image_gradients(img)
return tf.sqrt(tf.square(imgX) + tf.square(imgY), name='xHighPass')
elif mode == 'fft':
# n, h, w, c = tf.shape(img)
n = 5
h = 320
w = 320
c = 1
# freq_thershold = paras.get('freq_thershold', int(h/3))
# # freq_thershold = int(h/3)
freq_thershold = 8
# img = tf.reshape(img[:,:,:,0], [5, 320,320,1])
img_fft = tf.fft3d(tf.cast(img, tf.complex64))
# left = freq_thershold; right = w - freq_thershold
# up = freq_thershold; down = h - freq_thershold
mask = np.zeros((h, w, c))
mask[freq_thershold:h - freq_thershold, :, :] = 1
mask[:, freq_thershold:w - freq_thershold, :] = 1
# maskHP = np.zeros((h, w))
# maskHP[freqThreshold_HP:h-freqThreshold_HP, :] = 1
# maskHP[:, freqThreshold_HP:w-freqThreshold_HP] = 1
# mask = np.ones([h, w, c])
# mask[up:down, left:right, :] = 0
# plt.imsave('./highPass_mask.png', mask, cmap='gray')
# plt.imsave('./highPass_masked.png', mask, cmap='gray')
return tf.real(tf.ifft3d(tf.multiply(img_fft, mask)))
# return tf.ifft(tf.multiply(img_fft, mask))
# return tf.real(tf.ifft(tf.fft(tf.cast(img, tf.complex64))))
elif mode == 'fft_Gaussian':
mask = 1 - get_Gaussian_mask(0.007, 0.001, 320, 320)
img_fft = tf.fft3d(tf.cast(img, tf.complex64))
return tf.real(tf.ifft3d(tf.multiply(img_fft, mask)))
def defineShrinkwrap(self, varDict, gpu):
# Array coordinates
x, y, z = np.meshgrid(list(range(varDict['cImage'].shape[0])),
list(range(varDict['cImage'].shape[1])),
list(range(varDict['cImage'].shape[2])))
y = y.max() - y
x = x - x.mean()
y = y - y.mean()
z = z - z.mean()
with tf.device('/gpu:%d' % gpu):
# these are Tensorflow variables
self._x = tf.constant(fftshift(x), dtype=tf.float32, name='x')
self._y = tf.constant(fftshift(y), dtype=tf.float32, name='y')
self._z = tf.constant(fftshift(z), dtype=tf.float32, name='z')
self._blurred = tf.Variable(np.zeros(varDict['support'].shape),
dtype=tf.complex64,
name='blurred')
self._dist = tf.Variable(tf.zeros(self._x.shape, dtype=tf.float32),
name='dist')
# These are shrinkwrap-specific symbolic ops
with tf.name_scope('Shrinkwrap'):
self._getNewDist = tf.assign(
self._dist,
tf.exp(self._neg * (self._x * self._x + self._y * self._y +
self._z * self._z) /
(self._sigma * self._sigma)),
name='getNewDist')
# self._copyDistToRollBuffer = tf.assign( self._rollBuffer, tf.cast( self._dist, dtype=tf.complex64 ), name='CopyDistToRollBuffer' )
# self._retrieveDistFromRollBuffer = tf.assign( self._blurred, self._rollBuffer, name='retrieveDistFromRollBuffer' )
# self._copyImageToRollBuffer = tf.assign( self._rollBuffer, tf.cast( tf.abs( self._cImage ), dtype=tf.complex64 ), name='copyImgToRollBuffer' )
# self._convolveRollBufferWithBlur = tf.assign( self._rollBuffer, self._rollBuffer*self._blurred, name='convolve' )
# self._retrieveBlurred = tf.assign( self._blurred, self._rollBuffer, name='retrieveBlurred' )
self._blurShape = tf.assign(
self._blurred,
tf.ifft3d(
tf.fft3d( tf.cast( self._dist, dtype=tf.complex64 ) ) *\
tf.fft3d( tf.cast( tf.abs( self._cImage ), dtype=tf.complex64 ) )
),
name='blurShape'
)
self._updateSupport = tf.assign(
self._support,
tf.cast(
tf.abs(self._blurred) >
self._thresh * tf.reduce_max(tf.abs(self._blurred)),
tf.complex64),
name='updateSup')
self._updateSupComp = tf.assign(
self._support_comp,
tf.cast(
tf.abs(self._blurred) <=
self._thresh * tf.reduce_max(tf.abs(self._blurred)),
tf.complex64),
name='updateSupComp')
def __ERKernel__(self, mycount, myimage, myimage_fft_mod):
myimage = tf.ifft3d(
tf.multiply(
self._modulus,
tf.exp(
tf.complex(tf.zeros(myimage.shape),
tf.angle(tf.fft3d(myimage))))))
myimage = tf.multiply(myimage, self._support)
myimage_fft_mod = tf.cast(tf.abs(tf.fft3d(myimage)),
dtype=tf.complex64)
mycount -= 1
return mycount, myimage, myimage_fft_mod
def fft3d(input, gamma=0.1):
input = apodize3d(input, napodize=5)
temp = K.permute_dimensions(input, (0, 4, 1, 2, 3))
fft = tf.fft3d(tf.complex(temp, tf.zeros_like(temp)))
absfft = tf.pow(tf.abs(fft) + 1e-8, gamma)
output = K.permute_dimensions(absfft, (0, 2, 3, 4, 1))
return output
def visualize_FC_neuron():
# create natural image power spectrum
nimg_spectrum = np.fromfunction(lambda i, j, k: 1 / (
(i + 1)**2 + (j + 1)**2) + (k + 1**2), (227, 277, 3),
dtype=complex64)
nimg_spectrum = tf.reshape(nimg_spectrum, (227, 277, 3))
fc8_neuron = fc8[0, 107]
optimizer = tf.train.GradientDescentOptimizer(0.1)
x = tf.fft3d(tf.cast(input_var[0], dtype=complex64))
# print(x.get_shape(), nimg_spectrum.get_shape())
regularization = tf.norm(nimg_spectrum - x)
train = optimizer.minimize(-fc8_neuron + regularization)
sess = tf.Session()
sess.run(init)
max = 0
image = None
for step in range(STEPS_NUM):
sess.run(train)
neuron = sess.run(fc8_neuron)
# when the neuron's value is maximal, save the input image
if neuron > max:
image = sess.run(input_var)
max = neuron
print("step: ", step, " neuron: ", neuron, " regularization: ",
sess.run(regularization))
if image is None:
print('you have a problem')
else:
scipy.misc.imsave("fc_visualization.jpg", image[0])
def initialize_space_space_domain(self):
if self.use_spatial_patching:
recon_shape = self.recon_shape_full
else:
recon_shape = self.recon_shape
if self.use_deep_image_prior:
with tf.variable_scope('deep_image_prior'):
self.deep_image_prior()
else:
if self.DT_recon_r_initialize is not None:
self.DT_recon_r = tf.Variable(self.DT_recon_r_initialize,
dtype=tf.float32,
name='recon_real')
else:
self.DT_recon_r = tf.get_variable(
shape=recon_shape,
dtype=tf.float32,
initializer=tf.random_uniform_initializer(0, 1e-7),
name='recon_real')
self.DT_recon_i = tf.get_variable(
shape=recon_shape,
dtype=tf.float32,
initializer=tf.random_uniform_initializer(0, 1e-7),
name='recon_imag')
self.DT_recon = tf.complex(self.DT_recon_r, self.DT_recon_i)
self.k_space = self.tf_ifftshift3(
tf.fft3d(self.tf_fftshift3(self.DT_recon)))
def my_ft3d(tensor, scaling=1.):
"""
fftshift(fft(ifftshift(a)))
Applies shifts to work with arrays whose "zero" is in the middle
instead of the first element.
Uses standard normalization of fft unlike dip_image.
"""
return fftshift(tf.fft3d(ifftshift(tensor))) / scaling
def fft(self, x):
rank = len(x.shape) - 2
assert rank >= 1
if rank == 1:
return tf.stack([tf.fft(c) for c in tf.unstack(x, axis=-1)], axis=-1)
elif rank == 2:
return tf.stack([tf.fft2d(c) for c in tf.unstack(x, axis=-1)], axis=-1)
elif rank == 3:
return tf.stack([tf.fft3d(c) for c in tf.unstack(x, axis=-1)], axis=-1)
else:
raise NotImplementedError('n-dimensional FFT not implemented.')
def __SFKernel__(self, mycount, myimage, myimage_fft_mod):
myimage = 2. * (self._support * myimage) - myimage
myimage = tf.ifft3d(
tf.multiply(
self._modulus,
tf.exp(
tf.complex(tf.zeros(myimage.shape),
tf.angle(tf.fft3d(myimage))))))
myimage = 2. * (self._support * myimage) - myimage
mycount -= 1
return mycount, myimage, myimage_fft_mod
def __HIOKernel__(self, mycount, myimage, myimage_fft_mod):
origImage = tf.identity(myimage)
myimage = tf.ifft3d(
tf.multiply(
self._modulus,
tf.exp(
tf.complex(tf.zeros(myimage.shape),
tf.angle(tf.fft3d(myimage))))))
myimage = tf.multiply(self._support, myimage) + tf.multiply(
self._support_comp, origImage - self._beta * myimage)
mycount -= 1
return mycount, myimage, myimage_fft_mod
def conv3d_fft_tf(vol, otf):
input = tf.complex(vol, tf.zeros(vol.shape, dtype=tf.float32))
input = tf.cast(input, dtype=tf.complex64)
otf = tf.cast(otf, dtype=tf.complex64)
vol_fft = tf.fft3d(input)
vol_fftshift = hp.fftshift3d(vol_fft)
vol_fftshift = tf.multiply(vol_fftshift, otf)
vol_fftshift = hp.ifftshift3d(vol_fftshift)
vol_fft = tf.ifft3d(vol_fftshift)
return abssqr_tf(vol_fft)
def fft3d_b01c(x_b01c):
#x_shape=tf.to_int64(tf.shape(x_b01c))
x = int(x_b01c.get_shape()[1])
y = int(x_b01c.get_shape()[2])
z = int(x_b01c.get_shape()[3])
# fft2d for b01c type images. fft2d performs only for inner most 2 dims, so
# we need transpose to put w, h dim to the final 2 dims.
x_bc01 = tf.transpose(x_b01c, (0, 4, 1, 2, 3))
fft_x_bc01 = tf.fft3d(x_bc01)
fft_x_b01c = tf.transpose(fft_x_bc01, (0, 2, 3, 4, 1))
return (fft_x_b01c) / (x * y * z)
def defineER(self, gpu): # symbolic ops for error reduction
with tf.device('/gpu:%d' % gpu):
with tf.name_scope('DiffractionPattern'):
self._getIntermediateFFT = tf.assign(self._intermedFFT,
tf.fft3d(self._cImage),
name='intermedFFT')
self._getIntermediateInt = tf.assign(
self._intermedInt,
tf.square(
tf.cast(tf.abs(self._intermedFFT),
dtype=tf.complex64)),
name='intermedInt')
def _ir2tf(imp_resp, shape, sess, dim=None, is_real=True):
"""Compute the transfer function of an impulse response (IR).
This function makes the necessary correct zero-padding, zero
convention, correct fft2, etc... to compute the transfer function
of IR. To use with unitary Fourier transform for the signal (ufftn
or equivalent).
Args:
imp_resp (ndarray/tensor): he impulse responses.
shape (tuple): A tuple of integer corresponding to the target shape of
the transfer function.
sess (InteractiveSession): Tensorflow session.
dim (int): The last axis along which to compute the transform. All
axes by default.
is_real (boolean): If True (default), imp_resp is supposed real and the
Hermitian property is used with rfftn Fourier transform.
Return:
tensor: The transfer function of shape ``shape``.
"""
if not dim:
if tf.contrib.framework.is_tensor(imp_resp):
dim = len(imp_resp.shape)
else:
dim = imp_resp.ndim
irpadded = tf.Variable(tf.zeros(shape))
init_op = tf.variables_initializer([irpadded])
sess.run(init_op)
if tf.contrib.framework.is_tensor(imp_resp):
imp_shape = tuple(tf.shape(imp_resp).eval())
else:
imp_shape = imp_resp.shape
op = tf.assign(irpadded[tuple([slice(0, s) for s in imp_shape])], imp_resp)
sess.run(op)
for axis, axis_size in enumerate(imp_shape):
if axis >= len(imp_resp.shape) - dim:
irpadded = tf.manip.roll(
irpadded,
shift=-tf.cast(tf.math.floor(axis_size / 2), tf.int32),
axis=axis)
if dim == 1:
return tf.spectral.rfft(irpadded) if is_real else tf.fft(
tf.cast(irpadded, tf.complex64))
elif dim == 2:
return tf.spectral.rfft2d(irpadded) if is_real else tf.fft2d(
tf.cast(irpadded, tf.complex64))
elif dim == 3:
return tf.spectral.rfft3d(irpadded) if is_real else tf.fft3d(
tf.cast(irpadded, tf.complex64))
else:
raise ValueError('Bad dimension, dim can only be 1, 2 and 3')
def conv3d_fft_tf(vol, otf):
''' convolve given volume with OTF
Requirement/Assumption:
volumne AND OTF are not shifted
'''
# input = tf.complex(vol, tf.zeros(vol.shape, dtype=tf.float32))
input = tf.cast(vol, dtype=tf.complex64)
otf = tf.cast(otf, dtype=tf.complex64)
vol_fft = tf.fft3d(input)
# vol_fftshift = hp.fftshift3d(vol_fft)
vol_fftshift = tf.multiply(vol_fft, otf)
# vol_fftshift = hp.ifftshift3d(vol_fftshift)
vol_fft = tf.ifft3d(vol_fftshift)
return tf.real(vol_fft)
def get_lowPass(img, mode='average', paras={}):
if mode == 'average':
size = paras.get('size', 7)
lowPassFilter_C3 = tf.constant(1 / size**2,
shape=[size, size, 3, 3],
name='lowPass_filter_C1')
return tf.nn.conv2d(img,
lowPassFilter_C3,
strides=[1, 1, 1, 1],
padding='SAME',
name='xlowPass')
elif mode == 'fft':
# n, h, w, c = img.shape
n = 5
h = 320
w = 320
c = 1
# img = tf.reshape(img[:,:,:,0], [5, 320,320,1])
# freq_thershold = paras.get('freq_thershold', int(h/3))
freq_thershold = 8
img_fft = tf.fft3d(tf.cast(img, tf.complex64))
# left = freq_thershold; right = w - freq_thershold
# up = freq_thershold; down = h - freq_thershold
# mask = np.ones([h, w, c])
# mask = np.zeros([h, w, c])
# mask[up:down, left:right, :] = 1
mask = np.ones((h, w, c))
mask[freq_thershold:h - freq_thershold, :, :] = 0
mask[:, freq_thershold:w - freq_thershold, :] = 0
return tf.real(tf.ifft3d(tf.multiply(img_fft, mask)))
# return tf.ifft(tf.multiply(img_fft, mask))
# return tf.real(tf.ifft(tf.fft(tf.cast(img, tf.complex64))))
elif mode == 'fft_Gaussian':
mask = get_Gaussian_mask(0.007, 0.001, 320, 320)
img_fft = tf.fft3d(tf.cast(img, tf.complex64))
return tf.real(tf.ifft3d(tf.multiply(img_fft, mask)))
def fftconvolve3d(x, y, padding):
# FIXME SAME will not work correctly
# FIXME specifically designed for normxcorr (need to work more to make it general)
# Read shapes
x_shape = np.array(tuple(x.get_shape().as_list()), dtype=np.int32)
y_shape = np.array(tuple(y.get_shape().as_list()), dtype=np.int32)
# Construct paddings and pad
x_shape[1:4] = x_shape[1:4] - 1
y_pad = [[0, 0], [0, x_shape[1]], [0, x_shape[2]], [0, x_shape[3]]]
y_shape[1:4] = y_shape[1:4] - 1
x_pad = [[0, 0], [0, y_shape[1]], [0, y_shape[2]], [0, y_shape[3]]]
x = tf.pad(x, x_pad)
y = tf.pad(y, y_pad)
y = tf.cast(y, tf.complex64, name='complex_Y')
x = tf.cast(x, tf.complex64, name='complex_X')
convftt = tf.real(
tf.ifft3d(tf.multiply(tf.fft3d(x), tf.fft3d(y), name='fft_mult')))
print(convftt.get_shape())
#Slice correctly based on requirements
if padding == 'VALID':
begin = [0, y_shape[1], y_shape[2], y_shape[3]]
size = [
x_shape[0], x_shape[1] - y_shape[1], x_shape[2] - y_shape[1], 1
]
if padding == 'SAME':
begin = [0, y_shape[1] / 2 - 1, y_shape[2] / 2 - 1, y_shape[3] - 1]
size = x_shape #[-1, x_shape[0], x_shape[1]]
z = tf.slice(convftt, begin, size)
z = tf.squeeze(z)
return z
def gpu_gaussian_random_field(size=32, scale=1, length=48 * 28):
shape = (size, size, length)
amplitude = tf.constant(form_spectral_matrix(shape), dtype=tf.float32)
complex_amplitude = tf.complex(amplitude, tf.zeros(shape,
dtype=tf.float32))
random_noise = tf.random_normal(shape=shape,
stddev=scale,
dtype=tf.float32)
zeros = tf.zeros(shape, dtype=tf.float32)
complex_noise = tf.complex(random_noise, zeros)
noise_spectrum = tf.fft3d(complex_noise)
convolved = tf.multiply(complex_amplitude, noise_spectrum)
simulation = tf.ifft3d(convolved)
with tf.Session() as sess:
result = sess.run(simulation)
return result
def upsample_FT(inputs, upsam_size, scope, data_format='channels_last'):
if data_format == 'channels_first' or data_format == 'NCDHW':
raise RuntimeError("This has not been tested for channels_first")
sh = np.array(inputs.shape.as_list())
f_ny_old = sh // 2 #nyqvist frequency of original tensor
with tf.name_scope(scope):
t_cmplx = tf.complex(inputs, tf.zeros(inputs.shape))
t_cmplx_ft = tf.fft3d(t_cmplx)
t_cmplx_ft_pad = tf.manip.roll(t_cmplx_ft, f_ny_old, axis=(0, 1, 2))
t_cmplx_ft_pad = tf.pad(
t_cmplx_ft_pad, ((0, (upsam_size[0] - 1) * t_cmplx_ft.shape[0]),
(0, (upsam_size[1] - 1) * t_cmplx_ft.shape[1]),
(0, (upsam_size[2] - 1) * t_cmplx_ft.shape[2])),
'constant')
t_cmplx_ft_pad = tf.manip.roll(t_cmplx_ft_pad,
-f_ny_old,
axis=(0, 1, 2))
t_upsam = tf.real(tf.ifft3d(t_cmplx_ft_pad))
# the test found a significant imag part though --> bc of hard edge?
return t_upsam
def tensor_t_compress(A,k,n,m):
D = tf.fft3d(A);
#n = np.shape(A,3);
Uy=tf.Variable(tf.zeros(k,m,n))
for i in n:
Ux,Sx,Vx = np.linalg.svd(D[:,:,i])
Uy[:,:,i].assign(processU(Ux,k))
# Sy[:,:,i] = processS(Sx,k)
# Vy[:,:,i] = processV(Vx,k)
# U = ifft(Uy,[],3);
# S = ifft(Sy,[],3);
# V = ifft(Vy,[],3);
(n1,n2,n3) =tf.shape(Ux)
(m1,m2,m3) = tf.shape(A)
# if n2!= m1 and n3 != m3：
# error('Inner tensor dimensions must agree.');
C =tf.Variable(tf.zeros(n1,m2,n3));
# first frontal slice
halfn3 = np.round(n3/2.0)
for i in range(halfn3):
C[:,:,i].assign(np.transpose(Ux[:,:,i])*D[:,:,i])
C[:,:,n3+2-i].assign(np.conjuate(C[:,:,i]))
C[:,:,1].assign(np.dot(np.transpose(Ux[:,:,1]),A[:,:,1]))
if np.mod(n3,2) == 0:
i = halfn3+1
C[:,:,i].assign(np.transpose(Uy[:,:,i])*D[:,:,i])
C = tf.spectral.ifft3d(C)
return C
def computemodel(self):
''' Perform Multiple Scattering here
1.) Multiple Scattering is perfomed by slice-wise propagation the E-Field throught the sample
2.) Each Field has to be backprojected to the BFP
3.) Last step is to ceate a focus-stack and sum over all angles
This is done for all illumination angles (coming from illumination NA
simultaneasly)'''
print("Buildup Q-PHASE Model ")
###### make sure, that the first dimension is "batch"-size; in this case it is the illumination number
# @beniroquai It's common to have to batch dimensions first and not last.!!!!!
# the following loop propagates the field sequentially to all different Z-planes
## propagate the field through the entire object for all angles simultaneously
A_prop = np.transpose(
self.A_input,
[3, 0, 1, 2
]) # ??????? what the hack is happening with transpose?!
myprop = np.exp(1j * self.dphi) * (self.dphi > 0)
# excludes the near field components in each step
myprop = tf_helper.repmat4d(myprop, self.Nc)
myprop = np.transpose(
myprop, [3, 0, 1, 2
]) # ??????? what the hack is happening with transpose?!
RefrEffect = 1j * self.dz * self.k0 * self.RefrCos
# Precalculate the oblique effect on OPD to speed it up
RefrEffect = np.transpose(RefrEffect, [3, 0, 1, 2])
# for now orientate the dimensions as (alpha_illu, x, y, z) - because tensorflow takes the first dimension as batch size
with tf.name_scope('Variable_assignment'):
self.TF_A_input = tf.constant(A_prop, dtype=tf.complex64)
self.TF_RefrEffect = tf.reshape(
tf.constant(RefrEffect, dtype=tf.complex64), [self.Nc, 1, 1])
self.TF_myprop = tf.squeeze(tf.constant(myprop,
dtype=tf.complex64))
self.TF_Po = tf.cast(tf.constant(self.Po), tf.complex64)
self.TF_Zernikes = tf.constant(self.myzernikes, dtype=tf.float32)
if (self.is_optimization_psf):
self.TF_zernikefactors = tf.Variable(self.zernikefactors,
dtype=tf.float32,
name='var_zernikes')
else:
self.TF_zernikefactors = tf.constant(self.zernikefactors,
dtype=tf.float32,
name='const_zernikes')
# TODO: Introduce the averraged RI along Z - MWeigert
self.TF_A_prop = tf.squeeze(self.TF_A_input)
self.U_z_list = []
# Initiliaze memory
self.allInt = 0
self.allSumAmp = 0
self.TF_allSumAmp = tf.zeros([self.mysize[0], self.Nx, self.Ny],
dtype=tf.complex64)
self.tf_iterator = tf.Variable(1)
# simulate multiple scattering through object
with tf.name_scope('Fwd_Propagate'):
for pz in range(0, self.mysize[0]):
self.tf_iterator += self.tf_iterator
#self.TF_A_prop = tf.Print(self.TF_A_prop, [self.tf_iterator], 'Prpagation step: ')
with tf.name_scope('Refract'):
TF_f_phase = tf.cast(self.TF_obj_phase_do[pz, :, :],
tf.complex64)
self.TF_f = tf.exp(1j * self.TF_RefrEffect * TF_f_phase)
self.TF_A_prop = self.TF_A_prop * self.TF_f # refraction step
with tf.name_scope('Propagate'):
self.TF_A_prop = tf_helper.my_ift2d(
tf_helper.my_ft2d(self.TF_A_prop) *
self.TF_myprop) # diffraction step
# Bring the slice back to focus - does this make any sense?!
print('----------> Bringing field back to focus')
self.TF_A_prop = tf_helper.my_ift2d(
tf_helper.my_ft2d(self.TF_A_prop) *
(-self.Nz / 2 * self.TF_myprop)) # diffraction step
# in a final step limit this to the detection NA:
self.TF_Po_aberr = tf.exp(1j * tf.cast(
tf.reduce_sum(self.TF_zernikefactors * self.TF_Zernikes, axis=2),
tf.complex64)) * self.TF_Po
self.TF_A_prop = tf_helper.my_ift2d(
tf_helper.my_ft2d(self.TF_A_prop) * self.TF_Po_aberr)
self.TF_myAllSlicePropagator = tf.constant(self.myAllSlicePropagator,
dtype=tf.complex64)
self.kzcoord = np.reshape(self.kz[self.Ic > 0], [1, 1, 1, self.Nc])
# create Z-Stack by backpropagating Information in BFP to Z-Position
# self.mid3D = ([np.int(np.ceil(self.A_input.shape[0] / 2) + 1), np.int(np.ceil(self.A_input.shape[1] / 2) + 1), np.int(np.ceil(self.mysize[0] / 2) + 1)])
self.mid3D = ([
np.int(self.mysize[0] // 2),
np.int(self.A_input.shape[0] // 2),
np.int(self.A_input.shape[1] // 2)
])
with tf.name_scope('Back_Propagate'):
for pillu in range(0, self.Nc):
with tf.name_scope('Back_Propagate_Step'):
with tf.name_scope('Adjust'):
# fprintf('BackpropaAngle no: #d\n',pillu);
OneAmp = tf.expand_dims(self.TF_A_prop[pillu, :, :], 0)
# Fancy backpropagation assuming what would be measured if the sample was moved under oblique illumination:
# The trick is: First use conceptually the normal way
# and then apply the XYZ shift using the Fourier shift theorem (corresponds to physically shifting the object volume, scattered field stays the same):
self.TF_AdjustKXY = tf.squeeze(
tf.conj(self.TF_A_input[pillu, :, :, ])
) # tf.transpose(tf.conj(TF_A_input[pillu, :,:,]), [2, 1, 0]) # Maybe a bit of a dirty hack, but we first need to shift the zero coordinate to the center
self.TF_AdjustKZ = tf.transpose(
tf.constant(np.exp(
2 * np.pi * 1j * self.dz *
np.reshape(np.arange(0, self.mysize[0], 1),
[1, 1, self.mysize[0]]) *
self.kzcoord[:, :, :, pillu]),
dtype=tf.complex64), [2, 1, 0])
self.TF_allAmp = tf_helper.my_ift2d(
tf_helper.my_ft2d(OneAmp) *
self.TF_myAllSlicePropagator
) * self.TF_AdjustKZ * self.TF_AdjustKXY # * (TF_AdjustKZ); # 2x bfxfun. Propagates a single amplitude pattern back to the whole stack
self.TF_allAmp = self.TF_allAmp * tf.exp(
1j * tf.cast(
tf.angle(self.TF_allAmp[
self.mid3D[0], self.mid3D[1],
self.mid3D[2]]), tf.complex64)
) # Global Phases need to be adjusted at this step! Use the zero frequency
if (0):
with tf.name_scope('Propagate'):
self.TF_allAmp_3dft = tf.fft3d(
tf.expand_dims(self.TF_allAmp, axis=0))
self.TF_allAmp = self.TF_allAmp * tf.exp(
-1j * tf.cast(
tf.angle(self.TF_allAmp_3dft[
self.mid3D[2], self.mid3D[1],
self.mid3D[0]]), tf.complex64))
# Global Phases need to be adjusted at this step! Use the zero frequency
#print('Global phase: '+str(tf.exp(1j*tf.cast(tf.angle(self.TF_allAmp[self.mid3D[0],self.mid3D[1],self.mid3D[2]]), tf.complex64).eval()))
with tf.name_scope(
'Sum_Amps'
): # Normalize amplitude by condenser intensity
self.TF_allSumAmp = self.TF_allSumAmp + self.TF_allAmp #/ self.intensityweights[pillu]; # Superpose the Amplitudes
# print('Current illumination angle # is: ' + str(pillu))
# Normalize the image such that the values do not depend on the fineness of
# the source grid.
self.TF_allSumAmp = self.TF_allSumAmp / self.Nc #/tf.cast(tf.reduce_max(tf.abs(self.TF_allSumAmp)), tf.complex64)
# Following is the normalization according to Martin's book. It ensures
# that a transparent specimen is imaged with unit intensity.
# normfactor=abs(Po).^2.*abs(Ic); We do not use it, because it leads to
# divide by zero for dark-field system. Instead, through normalizations
# perfomed above, we ensure that image of a point under matched
# illumination is unity. The brightness of all the other configurations is
# relative to this benchmark.
#
# negate padding
if self.is_padding:
self.TF_allSumAmp = self.TF_allSumAmp[:, self.Nx // 2 -
self.Nx // 4:self.Nx // 2 +
self.Nx // 4, self.Ny // 2 -
self.Ny // 4:self.Ny // 2 +
self.Ny // 4]
return self.TF_allSumAmp
def test_FFT3D(self):
# only defined for gpu
if DEVICE == GPU:
t = tf.fft3d(self.random(3, 4, 5, complex=True))
self.check(t)
np.cos(2 * math.pi * LL)))
Lk = tf.placeholder("complex64", shape=(N, N, N))
Vk = tf.placeholder("complex64", shape=(N, N, N))
nkplace = tf.placeholder("complex64", shape=(N, N, N))
nrplace = tf.placeholder("complex64", shape=(N, N, N))
nk = tf.Variable(nkplace)
nr = tf.Variable(nrplace)
''' Control time step'''
dt = 0.0001
dtr = tf.constant(dt, dtype=tf.complex64)
Tr = tf.constant(Tr1, dtype=tf.complex64)
'''Update rule '''
SS = tf.log(nr / (1 - nr))
Sk = tf.fft3d(SS)
dnkdt = Lk * (Vk * nk / T0 + Tr * (Sk))
nk1 = nk + dnkdt * dtr
nr_ = tf.ifft3d(nk1)
step1 = tf.group(
nk.assign(nk1),
nr.assign(nr_),
)
'''Calculate order parameter '''
def make_kernel(a):
"""Transform a 3D array into a convolution kernel"""
a = np.asarray(a)
a = a.reshape(list(a.shape) + [1, 1])
def phase_corr(ashape, bshape, filter_shape=None):
"""Construct a TensorFlow op to compute phase correlation.
Parameters
----------
ashape : tuple of ints
Shape of input array.
bshape : tuple of ints
Shape of input array.
filter_shape : tuple
Shape of filter array. Optional. If not given, the window filter is
not applied.
Returns
-------
phase_corr : tf.Operation
The op to be run to compute phase correlation. When running the op,
values for the following placeholders must be fed:
`input/a_ph:0`, `input/b_ph:0`, `input/filter_ph:0`.
"""
my_filter_t = None
with tf.name_scope('input'):
aph = tf.placeholder(dtype=tf.uint16, shape=ashape, name='a_ph')
bph = tf.placeholder(dtype=tf.uint16, shape=bshape, name='b_ph')
if filter_shape is not None:
my_filter_t = tf.placeholder(dtype=tf.float32,
shape=filter_shape,
name='filter_ph')
at = tf.to_float(aph)
bt = tf.to_float(bph)
with tf.name_scope('subtract_mean'):
at -= tf.reduce_mean(at)
bt -= tf.reduce_mean(bt)
if filter_shape is not None:
with tf.name_scope('window_filter'):
at = at * my_filter_t
bt = bt * my_filter_t
with tf.name_scope('FFT'):
ac = tf.cast(at, tf.complex64, name='to_complex')
bc = tf.cast(bt, tf.complex64, name='to_complex')
aft = tf.fft3d(ac)
bft = tf.fft3d(bc)
with tf.name_scope('cross_power_spectrum'):
prod = aft * tf.conj(bft)
prodnorm = tf.abs(prod, name='norm')
ratio = prod / tf.cast(prodnorm, tf.complex64, name='to_complex')
with tf.name_scope('phase_correlation'):
ifft = tf.ifft3d(ratio)
phase_corr = tf.square(tf.real(ifft) + tf.square(tf.imag(ifft)))
phase_corr = tf.sqrt(phase_corr)
return phase_corr
def _ftconvolve(tensor1, tensor2):
return tf.real(tf.ifft3d(tf.fft3d(tensor1) * tf.fft3d(tensor2)))
def inference(self, use_bias=False):
self.config['ksize'] = 7
self.config['stride'] = 1
self.config['use_bias'] = True
with tf.variable_scope('sen1_1_1'): # sen1: 1,2
sen1_x_1 = self.in_sen1[..., :2]
sen1_abs_1 = self.in_sen1[..., :2]
sen1_1_complex = tf.complex(tf.expand_dims(sen1_abs_1[..., 0], axis=-1), tf.expand_dims(sen1_abs_1[..., 1], axis=-1))
sen1_abs_1 = tf.abs(sen1_1_complex)
sen1_angle_1 = tf.cast(tf.angle(sen1_1_complex), dtype=dtype)
sen1_fft_1 = tf.fft3d(sen1_1_complex)
sen1_fft_abs_1 = tf.abs(sen1_fft_1)
sen1_fft_angle_1 = tf.cast(tf.angle(sen1_fft_1), dtype=dtype)
sen1_x_1 = tf.concat([sen1_x_1, sen1_abs_1, sen1_angle_1, sen1_fft_abs_1, sen1_fft_angle_1], axis=-1)
sen1_x_1 = batch_normal(sen1_x_1, training=self.is_training)
with tf.variable_scope('block2'):
sen1_x_1 = self.cnns_stack_block_adj(sen1_x_1) # 16 * 16 * (256+4)=260
with tf.variable_scope('sen1_1_2'): # sen1: 3,4
sen1_x_2 = self.in_sen1[..., 2:4]
sen1_abs_2 = self.in_sen1[..., 2:4]
sen1_2_complex = tf.complex(tf.expand_dims(sen1_abs_2[..., 0], axis=-1), tf.expand_dims(sen1_abs_2[..., 1], axis=-1))
sen1_abs_2 = tf.abs(sen1_2_complex)
sen1_angle_2 = tf.cast(tf.angle(sen1_2_complex), dtype=dtype)
sen1_fft_2 = tf.fft3d(sen1_2_complex)
sen1_fft_abs_2 = tf.abs(sen1_fft_2)
sen1_fft_angle_2 = tf.cast(tf.angle(sen1_fft_2), dtype=dtype)
sen1_x_2 = tf.concat([sen1_x_2, sen1_abs_2, sen1_angle_2, sen1_fft_abs_2, sen1_fft_angle_2], axis=-1)
sen1_x_2 = batch_normal(sen1_x_2, training=self.is_training)
with tf.variable_scope('block2'):
sen1_x_2 = self.cnns_stack_block_adj(sen1_x_2) # 16 * 16 * (256+4)=260
with tf.variable_scope('sen1_1_3'): # sen1: 5,6
sen1_x_3 = self.in_sen1[..., 4:6]
sen1_abs_3 = self.in_sen1[..., 4:6]
sen1_3_complex = tf.complex(tf.expand_dims(sen1_abs_3[..., 0], axis=-1), tf.expand_dims(sen1_abs_3[..., 1], axis=-1))
sen1_abs_3 = tf.abs(sen1_3_complex)
sen1_angle_3 = tf.cast(tf.angle(sen1_3_complex), dtype=dtype)
sen1_fft_3 = tf.fft3d(sen1_3_complex)
sen1_fft_abs_3 = tf.abs(sen1_fft_3)
sen1_fft_angle_3 = tf.cast(tf.angle(sen1_fft_3), dtype=dtype)
sen1_x_3 = tf.concat([sen1_x_3, sen1_abs_3, sen1_angle_3, sen1_fft_abs_3, sen1_fft_angle_3], axis=-1)
sen1_x_3 = batch_normal(sen1_x_3, training=self.is_training)
with tf.variable_scope('block2'):
sen1_x_3 = self.cnns_stack_block_adj(sen1_x_3) # 16 * 16 * (256+2)=258
with tf.variable_scope('sen1_1_4'): # sen1: 7,8
sen1_x_4 = self.in_sen1[...,6:]
sen1_abs_4 = self.in_sen1[..., 6:]
sen1_4_complex = tf.complex(tf.expand_dims(sen1_abs_4[..., 0], axis=-1), tf.expand_dims(sen1_abs_4[..., 1], axis=-1))
sen1_abs_4 = tf.abs(sen1_4_complex)
sen1_angle_4 = tf.cast(tf.angle(sen1_4_complex), dtype=dtype)
sen1_fft_4 = tf.fft3d(sen1_4_complex)
sen1_fft_abs_4 = tf.abs(sen1_fft_4)
sen1_fft_angle_4 = tf.cast(tf.angle(sen1_fft_4), dtype=dtype)
sen1_x_4 = tf.concat([sen1_x_4, sen1_abs_4, sen1_angle_4, sen1_fft_abs_4, sen1_fft_angle_4], axis=-1)
sen1_x_4 = batch_normal(sen1_x_4, training=self.is_training)
with tf.variable_scope('block2'):
sen1_x_4 = self.cnns_stack_block_adj(sen1_x_4) # 16 * 16 * (256+2)=258
with tf.variable_scope('sen2_1_1'): # sen2: 1,2,3
sen2_x_1 = self.in_sen2[..., :3]
sen2_x_1 = batch_normal(sen2_x_1, training=self.is_training)
with tf.variable_scope('block2'):
sen2_x_1 = self.cnns_stack_block_adj(sen2_x_1) # 16 * 16 * 64
with tf.variable_scope('sen2_1_2'): # sen2: 4,5,6
sen2_x_2 = self.in_sen2[..., 3:6]
sen2_x_2 = batch_normal(sen2_x_2, training=self.is_training)
with tf.variable_scope('block2'):
sen2_x_2 = self.cnns_stack_block_adj(sen2_x_2) # 16 * 16 * 64
with tf.variable_scope('sen2_1_3'): # sen2: 7,8
sen2_x_3 = self.in_sen2[..., 6:8]
sen2_x_3 = batch_normal(sen2_x_3, training=self.is_training)
with tf.variable_scope('block2'):
sen2_x_3 = self.cnns_stack_block_adj(sen2_x_3) # 16 * 16 * 64
with tf.variable_scope('sen2_1_4'): # sen2: 9,10
sen2_x_4 = self.in_sen2[..., 8:]
sen2_x_4 = batch_normal(sen2_x_4, training=self.is_training)
with tf.variable_scope('block2'):
sen2_x_4 = self.cnns_stack_block_adj(sen2_x_4) # 16 * 16 * 64
sen1_x_1 = tf.concat([sen1_x_1, sen1_x_2, sen1_x_3, sen1_x_4], axis=-1) # 16 * 16 * (260+258+258+259)=1035
sen2_x_1 = tf.concat([sen2_x_1, sen2_x_2, sen2_x_3, sen2_x_4], axis=-1) # 16 * 16 * 266
with tf.variable_scope('sen1_2'):
with tf.variable_scope('block1'):
sen1_x = self.cnns_stack_block_adj_noscale(sen1_x_1)
with tf.variable_scope('block2'):
sen1_x = self.cnns_stack_block_adj(sen1_x) # 8 * 8 * (512+1035)=1547
with tf.variable_scope('block3'):
sen1_x = self.cnns_stack_block_adj_noscale(sen1_x)
with tf.variable_scope('sen2_2'):
with tf.variable_scope('block1'):
sen2_x = self.cnns_stack_block_adj_noscale(sen2_x_1)
with tf.variable_scope('block2'):
sen2_x = self.cnns_stack_block_adj(sen2_x) # 8 * 8 * (512+266)=778
with tf.variable_scope('block3'):
sen2_x = self.cnns_stack_block_adj_noscale(sen2_x)
x = tf.concat([sen1_x, sen2_x], axis=-1) # 8 * 8 * (1547+778)=2325
x_aux_2 = tf.reduce_mean(x, reduction_indices=[1, 2], name="avg_pool_aux2") # 1 * 1 * 3349
dims = x_aux_2.get_shape()[-1]
x_aux_2 = tf.reshape(x_aux_2, shape=(-1, dims))
with tf.variable_scope('fc1_aux2'):
self.config['fc_units_out'] = 526
x_aux_2 = self.fc(x_aux_2)
x_aux_2 = relu(x_aux_2)
with tf.variable_scope('fc2_aux2'):
self.config['fc_units_out'] = 1024
x_aux_2 = self.fc(x_aux_2)
x_aux_2 = relu(x_aux_2)
x_aux_2 = tf.nn.dropout(x_aux_2, self.keep_drop)
with tf.variable_scope('fc_proj_aux2'):
self.config['fc_units_out'] = self.config['label_class']
x_aux_2 = self.fc(x_aux_2)
self.logit_aux2 = x_aux_2
with tf.variable_scope('hub_1'):
with tf.variable_scope('block1'):
x = self.cnns_stack_block_adj_noscale(x)
with tf.variable_scope('block2'):
x = self.cnns_stack_block_adj(x) # 4 * 4 * (1024+2325)=3349
with tf.variable_scope('block3'):
x = self.cnns_stack_block_adj_noscale(x)
x = tf.reduce_mean(x, reduction_indices=[1, 2], name="avg_pool") # 1 * 1 * 3349
dims = x.get_shape()[-1]
x = tf.reshape(x, shape=(-1, dims))
with tf.variable_scope('fc1'):
self.config['fc_units_out'] = 1024
x = self.fc(x)
x = relu(x)
x = tf.nn.dropout(x, self.keep_drop)
with tf.variable_scope('fc_proj_hub'):
self.config['fc_units_out'] = self.config['label_class']
x = self.fc(x)
self.logit = x
self.output = softmax(x)
def defineBaseVariables(self, varDict, gpu):
# Tensorflow variables specified here.
with tf.device('/gpu:%d' % gpu):
self._modulus = tf.constant(varDict['modulus'],
dtype=tf.complex64,
name='mod_measured')
self._support = tf.Variable(varDict['support'],
dtype=tf.complex64,
name='sup')
self._support_comp = tf.Variable(1. - varDict['support'],
dtype=tf.complex64,
name='Support_comp')
self._cImage = tf.Variable(varDict['cImage'],
dtype=tf.complex64,
name='Image')
self._buffImage = tf.Variable(varDict['cImage'],
dtype=tf.complex64,
name='buffImage')
self._beta = tf.constant(varDict['beta'],
dtype=tf.complex64,
name='beta')
self._probSize = self._cImage.shape
self._thresh = tf.placeholder(dtype=tf.float32, name='thresh')
self._sigma = tf.placeholder(dtype=tf.float32, name='sigma')
self._neg = tf.constant(-0.5, dtype=tf.float32)
self._intermedFFT = tf.Variable(tf.zeros(self._cImage.shape,
dtype=tf.complex64),
name='intermedFFT')
self._intermedInt = tf.Variable(tf.zeros(self._cImage.shape,
dtype=tf.complex64),
name='intermedInt')
with tf.name_scope('Support'):
self._supproject = tf.assign(self._cImage,
self._cImage * self._support,
name='supProject')
# These are defined only if high-energy phasing is required.
if 'bin_left' in varDict.keys():
bL = varDict['bin_left']
sh = bL.shape
self._binL = tf.constant(bL.reshape(sh[0], sh[1], 1).repeat(
varDict['modulus'].shape[-1], axis=2),
dtype=tf.complex64,
name='binL')
self._binR = tf.constant(bL.T.reshape(sh[1], sh[0], 1).repeat(
varDict['modulus'].shape[-1], axis=2),
dtype=tf.complex64,
name='binR')
self._scale = tf.constant(varDict['scale'],
dtype=tf.complex64,
name='scale')
self._binned = tf.Variable(tf.zeros(self._modulus.shape,
dtype=tf.complex64),
name='binned')
self._expanded = tf.Variable(tf.zeros(self._support.shape,
dtype=tf.complex64),
name='expanded')
self._scaled = tf.Variable(tf.zeros(self._modulus.shape,
dtype=tf.complex64),
name='scaled')
with tf.name_scope('highEnergy'):
self._binThis = tf.assign(
self._binned,
tf.transpose(
tf.matmul(
tf.matmul(
tf.transpose(self._binL, [2, 0, 1]),
tf.transpose(
tf.cast(tf.square(
tf.abs(self._intermedFFT)),
dtype=tf.complex64),
[2, 0, 1])),
tf.transpose(self._binR, [2, 0, 1])),
[1, 2, 0]),
name='Binning')
self._scaleThis = tf.assign(self._scaled,
tf.divide(
self._modulus,
tf.sqrt(self._binned)),
name='Scaling')
self._expandThis = tf.assign(
self._expanded,
tf.transpose(
tf.matmul(
tf.matmul(
tf.transpose(self._binR, [2, 0, 1]),
tf.transpose(self._scaled, [2, 0, 1])),
tf.transpose(self._binL, [2, 0, 1])),
[1, 2, 0]),
name='Expansion')
self._HEImgUpdate = tf.assign(
self._cImage,
tf.multiply(
self._support,
tf.ifft3d(self._scale * tf.multiply(
self._expanded, self._intermedFFT))),
name='HEImgUpdate')
self._HEImgCorrect = tf.assign(
self._cImage,
self._cImage + tf.multiply(
self._support_comp,
self._buffImage - self._beta * self._cImage),
name='HEImgCorrect')
else: # regular phasing
with tf.name_scope('ER'):
self._modproject = tf.assign(
self._cImage,
tf.ifft3d(
tf.divide(self._modulus, tf.sqrt(
self._intermedInt)) * tf.fft3d(self._cImage)),
name='modProject')
return
def initializeGaussianPCF(self,
vardict,
array_shape,
gpu,
learning_rate=1.e-1):
x, y, z = np.meshgrid(list(range(array_shape[0])),
list(range(array_shape[1])),
list(range(array_shape[2])))
y = y.max() - y
x = (fftshift(x - x.mean())).reshape(1, -1)
y = (fftshift(y - y.mean())).reshape(1, -1)
z = (fftshift(z - z.mean())).reshape(1, -1)
pts = np.concatenate((x, y, z), axis=0)
if 'initial_guess' not in vardict.keys():
l1p, l2p, l3p, psip, thetap, phip = 2., 2., 2., 0., 0., 0.
else:
l1p, l2p, l3p, psip, thetap, phip = tuple(vardict['initial_guess'])
with tf.device('/gpu:%d' % gpu):
with tf.name_scope('GaussianPCF'):
self._roll = [n // 2 for n in self._probSize
] # defined in GPUModule_Base
with tf.name_scope('Constants'):
self._coherentEstimate = tf.Variable(
tf.zeros(self._cImage.shape, dtype=tf.float32),
name='coherentEstimate')
self._intensity = tf.constant(vardict['modulus']**2,
dtype=tf.float32,
name='Measurement')
self._q = tf.constant(pts,
dtype=tf.float32,
name='domainPoints')
self._v0 = tf.constant(np.array([1., 0.,
0.]).reshape(-1, 1),
dtype=tf.float32)
self._v1 = tf.constant(np.array([0., 1.,
0.]).reshape(-1, 1),
dtype=tf.float32)
self._v2 = tf.constant(np.array([0., 0.,
1.]).reshape(-1, 1),
dtype=tf.float32)
self._nskew0 = tf.constant(np.array([[0., 0., 0.],
[0., 0., -1.],
[0., 1., 0.]]),
dtype=tf.float32)
self._nskew1 = tf.constant(np.array([[0., 0., 1.],
[0., 0., 0.],
[-1., 0., 0.]]),
dtype=tf.float32)
self._nskew2 = tf.constant(np.array([[0., -1., 0.],
[1., 0., 0.],
[0., 0., 0.]]),
dtype=tf.float32)
self._one = tf.constant(1., dtype=tf.float32)
self._neg = tf.constant(-0.5, dtype=tf.float32)
self._twopi = tf.constant((2 * np.pi)**(3. / 2.),
dtype=tf.float32)
self._I = tf.eye(3)
with tf.name_scope('Parameters'):
self._l1 = tf.Variable(l1p,
dtype=tf.float32,
name='Lambda1') #
self._l2 = tf.Variable(
l2p, dtype=tf.float32, name='Lambda2'
) # Sqrt of eigenvalues of covariance matrix
self._l3 = tf.Variable(l3p,
dtype=tf.float32,
name='Lambda3') #
self._psi = tf.Variable(
psip, dtype=tf.float32,
name='Psi') # Rotation angle of eigenbasis
self._theta = tf.Variable(
thetap, dtype=tf.float32,
name='Theta') # Polar angle of rotation axis
self._phi = tf.Variable(
phip, dtype=tf.float32,
name='Phi') # Azimuth angle of rotation axis
with tf.name_scope('Auxiliary'):
self._FreqSupportMask = tf.placeholder(
dtype=tf.float32, shape=self._intensity.shape)
self._mD = tf.diag([self._l1, self._l2, self._l3])
self._n0 = tf.sin(self._theta) * tf.cos(self._phi)
self._n1 = tf.sin(self._theta) * tf.sin(self._phi)
self._n2 = tf.cos(self._theta)
self._n = self._n0 * self._v0 + self._n1 * self._v1 + self._n2 * self._v2
self._nskew = self._n0 * self._nskew0 + self._n1 * self._nskew1 + self._n2 * self._nskew2
self._R = tf.cos( self._psi )*self._I +\
tf.sin( self._psi )*self._nskew +\
( self._one - tf.cos( self._psi ) )*tf.matmul( self._n, tf.transpose( self._n ) )
self._C = tf.matmul(
self._R,
tf.matmul(tf.matmul(self._mD, self._mD),
tf.transpose(self._R)))
with tf.name_scope('Blurring'):
self._pkfft = tf.Variable(np.zeros(self._probSize),
dtype=tf.complex64,
name='pkfft')
self._blurKernel = tf.reshape(
tf.exp(self._neg * tf.reduce_sum(
self._q * tf.matmul(self._C, self._q), axis=0)),
shape=self._coherentEstimate.shape) * (
self._l1 * self._l2 * self._l3) / self._twopi
self._tf_intens_f = tf.fft3d(
tf.cast(self._coherentEstimate, dtype=tf.complex64))
self._tf_blur_f = tf.fft3d(
tf.cast(self._blurKernel, dtype=tf.complex64))
self._tf_prod_f = self._tf_intens_f * self._tf_blur_f
self._imgBlurred = tf.abs(tf.ifft3d(self._tf_prod_f))
with tf.name_scope('Optimizer'):
self._var_list = [
self._l1, self._l2, self._l3, self._psi, self._theta,
self._phi
]
self._poissonNLL = tf.reduce_mean(
self._FreqSupportMask *
(self._imgBlurred -
self._intensity * tf.log(self._imgBlurred)))
self._poissonOptimizer = tf.train.AdagradOptimizer(
learning_rate=vardict['pcc_learning_rate'],
name='poissonOptimize')
self._trainPoisson = self._poissonOptimizer.minimize(
self._poissonNLL, var_list=self._var_list)
self._currentGradients = [
n[0] for n in self._poissonOptimizer.compute_gradients(
self._poissonNLL, var_list=self._var_list)
]
# self._gaussNLL = tf.reduce_mean(
# self._FreqSupportMask * ( tf.sqrt( self._imgBlurred ) - tf.sqrt( self._intensity ) )**2
# )
# self._gaussOptimizer = tf.train.AdagradOptimizer( learning_rate=vardict[ 'pcc_learning_rate' ], name='gaussOptimize' )
# self._trainGauss = self._gaussOptimizer.minimize( self._gaussNLL, var_list=self._var_list )
# self._currentGradients = [
# n[0] for n in self._gaussOptimizer.compute_gradients( self._gaussNLL, var_list=self._var_list )
# ]
with tf.name_scope('Preparation'):
self._getCoherentEstimate = tf.assign(
self._coherentEstimate,
tf.cast(self._intermedInt, dtype=tf.float32),
name='getCoherentEstimate')
self._getPCFKernelFFT = tf.assign(
self._pkfft,
tf.fft3d(tf.cast(self._blurKernel,
dtype=tf.complex64)),
name='getPCFKernelFFT')
with tf.name_scope('Convolution'):
self._convolveWithCoherentEstimate = tf.assign(
self._intermedInt,
tf.cast(tf.abs(
tf.ifft3d(self._pkfft *
tf.fft3d(self._intermedInt))),
dtype=tf.complex64),
name='convolveWithCoherentEstimate')
self._progress = []
def fft2D(self, V):
''' gather view slices in FFT domain and reurn them '''
VF = tf.fft3d(V)
# 2D slices at planes locations
# symmetry x nviews x xdim x ydim x 3dcoord
return tf.gather_nd(VF, self._planes)
