def cnvtp(self, y):
"""
cnvtp computes the correlation of the convolution matrix with
either an image or a PSF whether , i.e. X'y or F'y respectively.
----------------------------------------------------------------------
Usage:
Call: Z = OlaGPU(z, sw, mode, winaux)
u = Z.cnvtp(y)
Input: y blurry image
Ouput: u either image or PSF sized object
"""
# Do chopping and padding of input
if self.mode == 'valid':
y_gpu = gputools.chop_pad_GPU(y, self.winaux.csf,
self.winaux.sw, self.winaux.nhop,
self.sfft_gpu, self.sf-1,'complex')
elif self.mode == 'same':
y_gpu = gputools.chop_pad_GPU(y, self.winaux.csf,
self.winaux.sw, self.winaux.nhop,
self.sfft_gpu, np.floor(self.sf/2),
'complex')
else:
raise NotImplementedError('Not a valid mode!')
# Compute FFT
self.fft(y_gpu, self.fft_gpu.shape[0])
z_gpu = cua.empty_like(y_gpu)
# Computing the inverse FFT
# z_gpu = (y_gpu * self.fft_gpu.conj()).conj()
z_gpu = y_gpu.conj() * self.fft_gpu
self.fft(z_gpu, self.fft_gpu.shape[0])
z_gpu = z_gpu.conj()/np.prod(z_gpu.shape[-2::])
# Do cropping to correct output size
if self.__id__ == 'X':
zc_gpu = gputools.crop_stack_GPU(z_gpu, self.sz)
return zc_gpu
elif self.__id__ == 'F':
zs_gpu = gputools.crop_stack_GPU(z_gpu, self.winaux.sw)
zs_gpu = self.winaux.ws_gpu * zs_gpu
zc_gpu = gputools.ola_GPU_test(zs_gpu, self.winaux.csf,
self.winaux.sw+self.sf-1,
self.winaux.nhop)
zc_gpu = gputools.crop_gpu2cpu(zc_gpu, self.sx)
return zc_gpu
def cnvtp(self, y):
"""
cnvtp computes the correlation of the convolution matrix with
either an image or a PSF whether , i.e. X'y or F'y respectively.
----------------------------------------------------------------------
Usage:
Call: Z = OlaGPU(z, sw, mode, winaux)
u = Z.cnvtp(y)
Input: y blurry image
Ouput: u either image or PSF sized object
"""
# Do chopping and padding of input
if self.mode == 'valid':
y_gpu = gputools.chop_pad_GPU(y, self.winaux.csf, self.winaux.sw,
self.winaux.nhop, self.sfft_gpu,
self.sf - 1, 'complex')
elif self.mode == 'same':
y_gpu = gputools.chop_pad_GPU(y, self.winaux.csf, self.winaux.sw,
self.winaux.nhop, self.sfft_gpu,
np.floor(self.sf / 2), 'complex')
else:
raise NotImplementedError('Not a valid mode!')
# Compute FFT
self.fft(y_gpu, self.fft_gpu.shape[0])
z_gpu = cua.empty_like(y_gpu)
# Computing the inverse FFT
# z_gpu = (y_gpu * self.fft_gpu.conj()).conj()
z_gpu = y_gpu.conj() * self.fft_gpu
self.fft(z_gpu, self.fft_gpu.shape[0])
z_gpu = z_gpu.conj() / np.prod(z_gpu.shape[-2::])
# Do cropping to correct output size
if self.__id__ == 'X':
zc_gpu = gputools.crop_stack_GPU(z_gpu, self.sz)
return zc_gpu
elif self.__id__ == 'F':
zs_gpu = gputools.crop_stack_GPU(z_gpu, self.winaux.sw)
zs_gpu = self.winaux.ws_gpu * zs_gpu
zc_gpu = gputools.ola_GPU_test(zs_gpu, self.winaux.csf,
self.winaux.sw + self.sf - 1,
self.winaux.nhop)
zc_gpu = gputools.crop_gpu2cpu(zc_gpu, self.sx)
return zc_gpu
def deconv(self, y, z0=None, mode='lbfgsb', maxfun=100, alpha=0., beta=0.01,
verbose=10, m=5, edgetapering=1, factor=3, gamma=1e-4):
"""
deconv implements various deconvolution methods. It expects a
blurry image and outputs an estimated blur kernel or a sharp latent
image. Currently, the following algorithms are implemented:
'lbfgsb' uses the lbfgsb optimization code to minimize the following
constrained regularized problem:
|y-Zu|^2 + alpha * |grad(u)|^2 + beta * |u|^2 s.t. u>0
The alpha term promotes smoothness of the solution, while
the beta term is an ordinary Thikhonov regularization
'direct' as above but solves the problem directly, i.e. via
division in Fourier space instead of an iterative
minimization scheme at the cost of the positivity
constraint.
'xdirect' as 'direct' but without corrective term which reduces
artifacts stemming from the windowing
'gdirect' solves the following problem
|grad(y)-grad(Zu)|^2 + alpha * |grad(u)|^2 + beta * |u|^2
This is particularly useful for kernel estimation in the
case of blurred natural images featuring many edges. The
advantage vs. 'direct' is the suppression of noise in the
estimated PSF kernels.
'xdirect' as 'direct' but without corrective term which reduces
artifacts stemming from the windowing
'Fast Image Deconvolution using Hyper-Laplacian Priors'
by Dilip Krishnan and Rob Fergus, NIPS 2009.
It minimizes the following problem
|y-Zu|^2 + gamma * |grad(u)|^(2/3)
via half-quadratic splitting. See paper for details.
----------------------------------------------------------------------
Usage:
Call: Z = OlaGPU(z, sw, mode, winaux)
u = Z.deconv(y)
Input: y blurry image
Ouput: u either image or PSF sized object
"""
from numpy import array
if not all(array(y.shape) == self.sy):
raise IOError ('Sizes incompatible. Expected blurred image!')
# Potential data transfer to GPU
if y.__class__ == cua.GPUArray:
y_gpu = 1. * y
else:
y_gpu = cua.to_gpu(y.astype(np.float32))
# --------------------------------------------------------------------
if mode == 'lbfgsb':
from scipy.optimize import fmin_l_bfgs_b
self.res_gpu = cua.empty_like(y_gpu)
if self.__id__ == 'X':
sz = ((int(np.prod(self.winaux.csf)),
int(self.sz[0]),int(self.sz[1])))
elif self.__id__ == 'F':
sz = self.sz
lf = np.prod(sz)
if z0 == None:
z0_gpu = self.cnvtp(y_gpu)
z0 = z0_gpu.get()
z0 = z0.flatten()
#z0 = np.ones(lf)/(1. * lf) # initialisation with flat kernels
else:
z0 = z0.flatten()
lb = 0. # lower bound
ub = np.infty # upper bound
zhat = fmin_l_bfgs_b(func = self.cnvinv_objfun, x0 = z0, \
fprime = self.cnvinv_gradfun,\
args = [sz, y_gpu, alpha, beta],\
factr = 10., pgtol = 10e-15, \
maxfun = maxfun, bounds = [(lb, ub)] * lf,\
m = m, iprint = verbose)
return np.reshape(zhat[0], sz), zhat[1], zhat[2]
# --------------------------------------------------------------------
elif mode == 'gdirect':
# Use this method only for estimating the PSF
if self.__id__ != 'X':
raise Exception('Use direct mode for image estimation!')
# Compute Laplacian
if alpha > 0.:
gx_gpu = gputools.pad_cpu2gpu(
np.array([[-1,1],[-1,1],[-1,1]]),
self.sfft_gpu, dtype='complex')
gy_gpu = gputools.pad_cpu2gpu(
np.array([[-1,-1,-1],[1,1,1]]),
self.sfft_gpu, dtype='complex')
self.plan.execute(gx_gpu)
self.plan.execute(gy_gpu)
L_gpu = gx_gpu * gx_gpu.conj() + gy_gpu * gy_gpu.conj()
else:
L_gpu = cua.zeros(self.fft_gpu.shape, np.complex64)
if edgetapering == 1:
gputools.edgetaper_gpu(y_gpu, 2*self.sf, 'barthann')
# Transfer to GPU
if self.x.__class__ == cua.GPUArray:
x_gpu = self.x
else:
x_gpu = cua.to_gpu(self.x)
# Compute gradient images
xx_gpu, xy_gpu = gputools.gradient_gpu(x_gpu)
yx_gpu, yy_gpu = gputools.gradient_gpu(y_gpu)
# Chop and pad business
if self.mode == 'valid':
yx_gpu = gputools.chop_pad_GPU(yx_gpu, self.winaux.csf,
self.winaux.sw, self.winaux.nhop,
self.sfft_gpu, self.sf-1,
'complex')
yy_gpu = gputools.chop_pad_GPU(yy_gpu, self.winaux.csf,
self.winaux.sw, self.winaux.nhop,
self.sfft_gpu, self.sf-1,
'complex')
elif self.mode == 'same':
yx_gpu = gputools.chop_pad_GPU(yx_gpu, self.winaux.csf,
self.winaux.sw, self.winaux.nhop,
self.sfft_gpu,
np.floor(self.sf/2), 'complex')
yy_gpu = gputools.chop_pad_GPU(yy_gpu, self.winaux.csf,
self.winaux.sw, self.winaux.nhop,
self.sfft_gpu,
np.floor(self.sf/2), 'complex')
else:
raise NotImplementedError('Not a valid mode!')
xx_gpu = gputools.chop_pad_GPU(xx_gpu, self.winaux.csf,
self.winaux.sw, self.winaux.nhop,
self.sfft_gpu, dtype='complex')
xy_gpu = gputools.chop_pad_GPU(xy_gpu, self.winaux.csf,
self.winaux.sw, self.winaux.nhop,
self.sfft_gpu, dtype='complex')
# Here each patch should be windowed to reduce ringing artifacts,
# however since we are working in the gradient domain, the effect
# is negligible
# ws_gpu = gputools.pad_stack_GPU(self.winaux.ws_gpu,
# self.sfft_gpu, self.sf-1,
# dtype='complex')
# xx_gpu = ws_gpu * xx_gpu
# xy_gpu = ws_gpu * xy_gpu
# yx_gpu = ws_gpu * yx_gpu
# yy_gpu = ws_gpu * yy_gpu
# Compute Fourier transform
self.fft(yx_gpu, self.fft_gpu.shape[0])
self.fft(yy_gpu, self.fft_gpu.shape[0])
self.fft(xx_gpu, self.fft_gpu.shape[0])
self.fft(xy_gpu, self.fft_gpu.shape[0])
# Do division in Fourier space
z_gpu = cua.zeros(xy_gpu.shape, np.complex64)
z_gpu = gputools.comp_ola_gdeconv(xx_gpu, xy_gpu,
yx_gpu, yy_gpu,
L_gpu, alpha, beta)
# Computing the inverse FFT
z_gpu = z_gpu.conj()
self.fft(z_gpu, self.fft_gpu.shape[0])
z_gpu = z_gpu.conj()/np.prod(z_gpu.shape[-2::])
# Crop out the kernels
zc_gpu = gputools.crop_stack_GPU(z_gpu, self.sf)
return zc_gpu
# --------------------------------------------------------------------
elif mode == 'direct':
const_gpu = cua.empty_like(y_gpu)
const_gpu.fill(1.)
# First deconvolution without corrective term
y_gpu = self.deconv(y_gpu, mode = 'xdirect', alpha = alpha,
beta = beta, edgetapering = edgetapering)
gputools.cliplower_GPU(y_gpu,0)
# Now same for constant image to get rid of window artifacts
if edgetapering == 1:
gputools.edgetaper_gpu(const_gpu, 2*self.sf, 'barthann')
const_gpu = self.deconv(const_gpu, mode = 'xdirect', alpha = alpha,
beta = beta, edgetapering = edgetapering)
gputools.edgetaper_gpu(const_gpu, 2*self.sf, 'barthann')
gputools.clip_GPU(const_gpu, 0.01, 10.)
# Division of deconvolved latent and constant image to get rid
# of artifacts stemming from windowing
y_gpu = y_gpu / const_gpu
sz = y_gpu.shape
#gputools.clip_GPU(y_gpu, 0., 1.0)
#gputools.edgetaper_gpu(y_gpu, 3*self.sf, 'barthann')
# Do cropping and padding since edges are corrupted by division
y_gpu = gputools.crop_gpu2cpu(y_gpu, sz-factor*self.sf-1,
offset=np.floor((factor*self.sf-1)/2.))
y_gpu = gputools.impad_gpu(y_gpu, tuple(np.array(sz)-y_gpu.shape))
return y_gpu
# --------------------------------------------------------------------
elif mode == 'xdirect':
# Compute Laplacian
if alpha > 0.:
gx_gpu = gputools.pad_cpu2gpu(
np.array([[-1,1]]), self.sfft_gpu, dtype='complex')
gy_gpu = gputools.pad_cpu2gpu(
np.array([[-1],[1]]), self.sfft_gpu, dtype='complex')
self.plan.execute(gx_gpu)
self.plan.execute(gy_gpu)
L_gpu = gx_gpu * gx_gpu.conj() + gy_gpu * gy_gpu.conj()
else:
L_gpu = cua.zeros(self.fft_gpu.shape, np.complex64)
# Edgetapering of blurry input image
if edgetapering == 1:
gputools.edgetaper_gpu(y_gpu, 3*self.sf, 'barthann')
if self.mode == 'valid':
#y_gpu = gputools.pad_cpu2gpu(y_gpu, self.sx, self.sf-1, dtype='real')
offset = self.sf-1
elif self.mode == 'same':
offset = np.floor(self.sf/2)
else:
raise NotImplementedError('Not a valid mode!')
# Chop and pad business
y_gpu = gputools.chop_pad_GPU(y, self.winaux.csf,
self.winaux.sw, self.winaux.nhop,
self.sfft_gpu, offset, 'complex')
ws_gpu = gputools.pad_stack_GPU(self.winaux.ws_gpu, self.sfft_gpu,
dtype='complex')
# Windowing
y_gpu = ws_gpu * y_gpu
# Compute FFT
self.fft(y_gpu, self.fft_gpu.shape[0])
# Do division in Fourier space
z_gpu = gputools.comp_ola_deconv(self.fft_gpu, y_gpu, L_gpu,
alpha, beta)
# Computing the inverse FFT
z_gpu = z_gpu.conj()
self.fft(z_gpu, self.fft_gpu.shape[0])
z_gpu = z_gpu.conj()/np.prod(z_gpu.shape[-2::])
# Crop the solution to correct output size
if self.__id__ == 'X':
zc_gpu = gputools.crop_stack_GPU(z_gpu, self.sf)
return zc_gpu
elif self.__id__ == 'F':
zs_gpu = gputools.crop_stack_GPU(z_gpu, self.winaux.sw)
#zs_gpu = self.winaux.ws_gpu * zs_gpu
zc_gpu = gputools.ola_GPU_test(zs_gpu, self.winaux.csf,
self.winaux.sw, self.winaux.nhop)
zc_gpu = gputools.crop_gpu2cpu(zc_gpu, self.sx)
return zc_gpu
# --------------------------------------------------------------------
elif mode == 'sparse':
# Compute Laplacian
gx_gpu = gputools.pad_cpu2gpu(np.sqrt(2.)/2. *
np.array([[-1,1]]), self.sfft_gpu, dtype='complex')
gy_gpu = gputools.pad_cpu2gpu(np.sqrt(2.)/2. *
np.array([[-1],[1]]), self.sfft_gpu, dtype='complex')
self.plan.execute(gx_gpu)
self.plan.execute(gy_gpu)
L_gpu = gx_gpu * gx_gpu.conj() + gy_gpu * gy_gpu.conj()
const_gpu = cua.empty_like(y_gpu)
const_gpu.fill(1.)
# Edgetapering
if edgetapering == 1:
gputools.edgetaper_gpu(y_gpu, 2*self.sf, 'barthann')
gputools.edgetaper_gpu(const_gpu, 2*self.sf, 'barthann')
# Parameter settings
beta = 1.
beta_rate = 2. * np.sqrt(2.)
beta_max = 2.**8
# Initialisation of x with padded version of y
x_gpu = 1 * y_gpu
if self.mode == 'valid':
offset = self.sf-1
elif self.mode == 'same':
offset = np.floor(self.sf/2)
else:
raise NotImplementedError('Not a valid mode!')
# Chop and pad business
y_gpu = gputools.chop_pad_GPU(y_gpu, self.winaux.csf,
self.winaux.sw, self.winaux.nhop,
self.sfft_gpu, offset,'complex')
const_gpu = gputools.chop_pad_GPU(const_gpu, self.winaux.csf,
self.winaux.sw, self.winaux.nhop,
self.sfft_gpu, offset,'complex')
ws_gpu = gputools.pad_stack_GPU(self.winaux.ws_gpu, self.sfft_gpu,
offset, dtype='complex')
# Windowing
y_gpu = y_gpu * ws_gpu
# Constant image for corrective weighting term
const_gpu = const_gpu * ws_gpu
del ws_gpu
self.fft(const_gpu, self.fft_gpu.shape[0])
const_gpu = gputools.comp_ola_deconv(self.fft_gpu, const_gpu,
L_gpu, alpha, gamma)
const_gpu = const_gpu.conj()
self.fft(const_gpu, self.fft_gpu.shape[0])
const_gpu = const_gpu.conj()/np.prod(const_gpu.shape[-2::])
const_gpu = gputools.crop_stack_GPU(const_gpu, self.winaux.sw)
const_gpu = const_gpu * self.winaux.ws_gpu
const_gpu = gputools.ola_GPU_test(const_gpu, self.winaux.csf,
self.winaux.sw, self.winaux.nhop)
const_gpu = gputools.crop_gpu2cpu(const_gpu, self.sx)
# For debugging purposes
#scipy.misc.imsave('const1.png', const_gpu.get()/const_gpu.get().max())
gputools.cliplower_GPU(const_gpu, 0.01)
const_gpu = 0.01 / const_gpu
# Precompute F'y
self.fft(y_gpu, self.fft_gpu.shape[0])
y_gpu = y_gpu * self.fft_gpu.conj()
while beta < beta_max:
# Compute gradient images of x
xx_gpu, xy_gpu = gputools.gradient_gpu(x_gpu)
del x_gpu
# w sub-problem for alpha 2/3
gputools.modify_sparse23_gpu(xx_gpu, beta)
gputools.modify_sparse23_gpu(xy_gpu, beta)
#gputools.modify_sparse_gpu(xx_gpu, beta, 0.01)
#gputools.modify_sparse_gpu(xy_gpu, beta, 0.01)
# Chop and pad to size of FFT
xx_gpu = gputools.chop_pad_GPU(xx_gpu, self.winaux.csf,
self.winaux.sw, self.winaux.nhop,
self.sfft_gpu, dtype='complex')
xy_gpu = gputools.chop_pad_GPU(xy_gpu, self.winaux.csf,
self.winaux.sw, self.winaux.nhop,
self.sfft_gpu, dtype='complex')
# Compute Fourier transform
self.fft(xx_gpu, self.fft_gpu.shape[0])
self.fft(xy_gpu, self.fft_gpu.shape[0])
# Do division in Fourier space
x_gpu = gputools.comp_ola_sdeconv(gx_gpu, gy_gpu,
xx_gpu, xy_gpu,
y_gpu, self.fft_gpu,
L_gpu, alpha, beta, gamma)
del xx_gpu, xy_gpu
# Computing the inverse FFT
x_gpu = x_gpu.conj()
self.fft(x_gpu, self.fft_gpu.shape[0])
x_gpu = x_gpu.conj()
x_gpu /= np.prod(x_gpu.shape[-2::])
# Ola and cropping
x_gpu = gputools.crop_stack_GPU(x_gpu, self.winaux.sw)
x_gpu = x_gpu * self.winaux.ws_gpu
x_gpu = gputools.ola_GPU_test(x_gpu, self.winaux.csf,
self.winaux.sw, self.winaux.nhop)
x_gpu = gputools.crop_gpu2cpu(x_gpu, self.sx)
# Enforce positivity
x_gpu = x_gpu * const_gpu
gputools.cliplower_GPU(x_gpu, 0.)
beta *= beta_rate
return x_gpu
else:
raise NotImplementedError('Not a valid deconv mode!')
def deconv(self,
y,
z0=None,
mode='lbfgsb',
maxfun=100,
alpha=0.,
beta=0.01,
verbose=10,
m=5,
edgetapering=1,
factor=3,
gamma=1e-4):
"""
deconv implements various deconvolution methods. It expects a
blurry image and outputs an estimated blur kernel or a sharp latent
image. Currently, the following algorithms are implemented:
'lbfgsb' uses the lbfgsb optimization code to minimize the following
constrained regularized problem:
|y-Zu|^2 + alpha * |grad(u)|^2 + beta * |u|^2 s.t. u>0
The alpha term promotes smoothness of the solution, while
the beta term is an ordinary Thikhonov regularization
'direct' as above but solves the problem directly, i.e. via
division in Fourier space instead of an iterative
minimization scheme at the cost of the positivity
constraint.
'xdirect' as 'direct' but without corrective term which reduces
artifacts stemming from the windowing
'gdirect' solves the following problem
|grad(y)-grad(Zu)|^2 + alpha * |grad(u)|^2 + beta * |u|^2
This is particularly useful for kernel estimation in the
case of blurred natural images featuring many edges. The
advantage vs. 'direct' is the suppression of noise in the
estimated PSF kernels.
'xdirect' as 'direct' but without corrective term which reduces
artifacts stemming from the windowing
'Fast Image Deconvolution using Hyper-Laplacian Priors'
by Dilip Krishnan and Rob Fergus, NIPS 2009.
It minimizes the following problem
|y-Zu|^2 + gamma * |grad(u)|^(2/3)
via half-quadratic splitting. See paper for details.
----------------------------------------------------------------------
Usage:
Call: Z = OlaGPU(z, sw, mode, winaux)
u = Z.deconv(y)
Input: y blurry image
Ouput: u either image or PSF sized object
"""
from numpy import array
if not all(array(y.shape) == self.sy):
raise IOError('Sizes incompatible. Expected blurred image!')
# Potential data transfer to GPU
if y.__class__ == cua.GPUArray:
y_gpu = 1. * y
else:
y_gpu = cua.to_gpu(y.astype(np.float32))
# --------------------------------------------------------------------
if mode == 'lbfgsb':
from scipy.optimize import fmin_l_bfgs_b
self.res_gpu = cua.empty_like(y_gpu)
if self.__id__ == 'X':
sz = ((int(np.prod(self.winaux.csf)), int(self.sz[0]),
int(self.sz[1])))
elif self.__id__ == 'F':
sz = self.sz
lf = np.prod(sz)
if z0 == None:
z0_gpu = self.cnvtp(y_gpu)
z0 = z0_gpu.get()
z0 = z0.flatten()
#z0 = np.zeros(self.sf) # initialisation with flat kernels
#z0[self.sf[0]/2,self.sf[1]/2] = 1.
#z0 = np.tile(z0, [np.prod(self.csf),1,1])
#z0 = z0.flatten()
else:
z0 = z0.flatten()
lb = 0. # lower bound
ub = np.infty # upper bound
zhat = fmin_l_bfgs_b(func = self.cnvinv_objfun, x0 = z0, \
fprime = self.cnvinv_gradfun,\
args = [sz, y_gpu, alpha, beta],\
factr = 10., pgtol = 10e-15, \
maxfun = maxfun, bounds = [(lb, ub)] * lf,\
m = m, iprint = verbose)
return np.reshape(zhat[0], sz), zhat[1], zhat[2]
# --------------------------------------------------------------------
elif mode == 'gdirect':
# Use this method only for estimating the PSF
if self.__id__ != 'X':
raise Exception('Use direct mode for image estimation!')
# Compute Laplacian
if alpha > 0.:
gx_gpu = gputools.pad_cpu2gpu(np.array([[-1, 1], [-1, 1],
[-1, 1]]),
self.sfft_gpu,
dtype='complex')
gy_gpu = gputools.pad_cpu2gpu(np.array([[-1, -1, -1],
[1, 1, 1]]),
self.sfft_gpu,
dtype='complex')
self.plan.execute(gx_gpu)
self.plan.execute(gy_gpu)
L_gpu = gx_gpu * gx_gpu.conj() + gy_gpu * gy_gpu.conj()
else:
L_gpu = cua.zeros(self.fft_gpu.shape, np.complex64)
if edgetapering == 1:
gputools.edgetaper_gpu(y_gpu, 2 * self.sf, 'barthann')
# Transfer to GPU
if self.x.__class__ == cua.GPUArray:
x_gpu = self.x
else:
x_gpu = cua.to_gpu(self.x)
# Compute gradient images
xx_gpu, xy_gpu = gputools.gradient_gpu(x_gpu)
yx_gpu, yy_gpu = gputools.gradient_gpu(y_gpu)
# Chop and pad business
if self.mode == 'valid':
yx_gpu = gputools.chop_pad_GPU(yx_gpu, self.winaux.csf,
self.winaux.sw,
self.winaux.nhop, self.sfft_gpu,
self.sf - 1, 'complex')
yy_gpu = gputools.chop_pad_GPU(yy_gpu, self.winaux.csf,
self.winaux.sw,
self.winaux.nhop, self.sfft_gpu,
self.sf - 1, 'complex')
elif self.mode == 'same':
yx_gpu = gputools.chop_pad_GPU(yx_gpu, self.winaux.csf,
self.winaux.sw,
self.winaux.nhop, self.sfft_gpu,
np.floor(self.sf / 2),
'complex')
yy_gpu = gputools.chop_pad_GPU(yy_gpu, self.winaux.csf,
self.winaux.sw,
self.winaux.nhop, self.sfft_gpu,
np.floor(self.sf / 2),
'complex')
else:
raise NotImplementedError('Not a valid mode!')
xx_gpu = gputools.chop_pad_GPU(xx_gpu,
self.winaux.csf,
self.winaux.sw,
self.winaux.nhop,
self.sfft_gpu,
dtype='complex')
xy_gpu = gputools.chop_pad_GPU(xy_gpu,
self.winaux.csf,
self.winaux.sw,
self.winaux.nhop,
self.sfft_gpu,
dtype='complex')
# Here each patch should be windowed to reduce ringing artifacts,
# however since we are working in the gradient domain, the effect
# is negligible
# ws_gpu = gputools.pad_stack_GPU(self.winaux.ws_gpu,
# self.sfft_gpu, self.sf-1,
# dtype='complex')
# xx_gpu = ws_gpu * xx_gpu
# xy_gpu = ws_gpu * xy_gpu
# yx_gpu = ws_gpu * yx_gpu
# yy_gpu = ws_gpu * yy_gpu
# Compute Fourier transform
self.fft(yx_gpu, self.fft_gpu.shape[0])
self.fft(yy_gpu, self.fft_gpu.shape[0])
self.fft(xx_gpu, self.fft_gpu.shape[0])
self.fft(xy_gpu, self.fft_gpu.shape[0])
# Do division in Fourier space
z_gpu = cua.zeros(xy_gpu.shape, np.complex64)
z_gpu = gputools.comp_ola_gdeconv(xx_gpu, xy_gpu, yx_gpu, yy_gpu,
L_gpu, alpha, beta)
# Computing the inverse FFT
z_gpu = z_gpu.conj()
self.fft(z_gpu, self.fft_gpu.shape[0])
z_gpu = z_gpu.conj() / np.prod(z_gpu.shape[-2::])
# Crop out the kernels
zc_gpu = gputools.crop_stack_GPU(z_gpu, self.sf)
return zc_gpu
# --------------------------------------------------------------------
elif mode == 'direct':
const_gpu = cua.empty_like(y_gpu)
const_gpu.fill(1.)
# First deconvolution without corrective term
y_gpu = self.deconv(y_gpu,
mode='xdirect',
alpha=alpha,
beta=beta,
edgetapering=edgetapering)
gputools.cliplower_GPU(y_gpu, 0)
# Now same for constant image to get rid of window artifacts
if edgetapering == 1:
gputools.edgetaper_gpu(const_gpu, 2 * self.sf, 'barthann')
const_gpu = self.deconv(const_gpu,
mode='xdirect',
alpha=alpha,
beta=beta,
edgetapering=edgetapering)
gputools.edgetaper_gpu(const_gpu, 2 * self.sf, 'barthann')
gputools.clip_GPU(const_gpu, 0.01, 10.)
# Division of deconvolved latent and constant image to get rid
# of artifacts stemming from windowing
y_gpu = y_gpu / const_gpu
sz = y_gpu.shape
#gputools.clip_GPU(y_gpu, 0., 1.0)
#gputools.edgetaper_gpu(y_gpu, 3*self.sf, 'barthann')
# Do cropping and padding since edges are corrupted by division
y_gpu = gputools.crop_gpu2cpu(y_gpu,
sz - factor * self.sf - 1,
offset=np.floor(
(factor * self.sf - 1) / 2.))
y_gpu = gputools.impad_gpu(y_gpu,
tuple(np.array(sz) - y_gpu.shape))
return y_gpu
# --------------------------------------------------------------------
elif mode == 'xdirect':
# Compute Laplacian
if alpha > 0.:
gx_gpu = gputools.pad_cpu2gpu(np.array([[-1, 1]]),
self.sfft_gpu,
dtype='complex')
gy_gpu = gputools.pad_cpu2gpu(np.array([[-1], [1]]),
self.sfft_gpu,
dtype='complex')
self.plan.execute(gx_gpu)
self.plan.execute(gy_gpu)
L_gpu = gx_gpu * gx_gpu.conj() + gy_gpu * gy_gpu.conj()
else:
L_gpu = cua.zeros(self.fft_gpu.shape, np.complex64)
# Edgetapering of blurry input image
if edgetapering == 1:
gputools.edgetaper_gpu(y_gpu, 3 * self.sf, 'barthann')
if self.mode == 'valid':
#y_gpu = gputools.pad_cpu2gpu(y_gpu, self.sx, self.sf-1, dtype='real')
offset = self.sf - 1
elif self.mode == 'same':
offset = np.floor(self.sf / 2)
else:
raise NotImplementedError('Not a valid mode!')
# Chop and pad business
y_gpu = gputools.chop_pad_GPU(y, self.winaux.csf, self.winaux.sw,
self.winaux.nhop, self.sfft_gpu,
offset, 'complex')
ws_gpu = gputools.pad_stack_GPU(self.winaux.ws_gpu,
self.sfft_gpu,
dtype='complex')
# Windowing
y_gpu = ws_gpu * y_gpu
# Compute FFT
self.fft(y_gpu, self.fft_gpu.shape[0])
# Do division in Fourier space
z_gpu = gputools.comp_ola_deconv(self.fft_gpu, y_gpu, L_gpu, alpha,
beta)
# Computing the inverse FFT
z_gpu = z_gpu.conj()
self.fft(z_gpu, self.fft_gpu.shape[0])
z_gpu = z_gpu.conj() / np.prod(z_gpu.shape[-2::])
# Crop the solution to correct output size
if self.__id__ == 'X':
zc_gpu = gputools.crop_stack_GPU(z_gpu, self.sf)
return zc_gpu
elif self.__id__ == 'F':
zs_gpu = gputools.crop_stack_GPU(z_gpu, self.winaux.sw)
#zs_gpu = self.winaux.ws_gpu * zs_gpu
zc_gpu = gputools.ola_GPU_test(zs_gpu, self.winaux.csf,
self.winaux.sw,
self.winaux.nhop)
zc_gpu = gputools.crop_gpu2cpu(zc_gpu, self.sx)
return zc_gpu
# --------------------------------------------------------------------
elif mode == 'sparse':
# Compute Laplacian
gx_gpu = gputools.pad_cpu2gpu(np.sqrt(2.) / 2. *
np.array([[-1, 1]]),
self.sfft_gpu,
dtype='complex')
gy_gpu = gputools.pad_cpu2gpu(np.sqrt(2.) / 2. *
np.array([[-1], [1]]),
self.sfft_gpu,
dtype='complex')
self.plan.execute(gx_gpu)
self.plan.execute(gy_gpu)
L_gpu = gx_gpu * gx_gpu.conj() + gy_gpu * gy_gpu.conj()
const_gpu = cua.empty_like(y_gpu)
const_gpu.fill(1.)
# Edgetapering
if edgetapering == 1:
gputools.edgetaper_gpu(y_gpu, 2 * self.sf, 'barthann')
gputools.edgetaper_gpu(const_gpu, 2 * self.sf, 'barthann')
# Parameter settings
beta = 1.
beta_rate = 2. * np.sqrt(2.)
beta_max = 2.**8
# Initialisation of x with padded version of y
x_gpu = 1 * y_gpu
if self.mode == 'valid':
offset = self.sf - 1
elif self.mode == 'same':
offset = np.floor(self.sf / 2)
else:
raise NotImplementedError('Not a valid mode!')
# Chop and pad business
y_gpu = gputools.chop_pad_GPU(y_gpu, self.winaux.csf,
self.winaux.sw, self.winaux.nhop,
self.sfft_gpu, offset, 'complex')
const_gpu = gputools.chop_pad_GPU(const_gpu, self.winaux.csf,
self.winaux.sw, self.winaux.nhop,
self.sfft_gpu, offset, 'complex')
ws_gpu = gputools.pad_stack_GPU(self.winaux.ws_gpu,
self.sfft_gpu,
offset,
dtype='complex')
# Windowing
y_gpu = y_gpu * ws_gpu
# Constant image for corrective weighting term
const_gpu = const_gpu * ws_gpu
del ws_gpu
self.fft(const_gpu, self.fft_gpu.shape[0])
const_gpu = gputools.comp_ola_deconv(self.fft_gpu, const_gpu,
L_gpu, alpha, gamma)
const_gpu = const_gpu.conj()
self.fft(const_gpu, self.fft_gpu.shape[0])
const_gpu = const_gpu.conj() / np.prod(const_gpu.shape[-2::])
const_gpu = gputools.crop_stack_GPU(const_gpu, self.winaux.sw)
const_gpu = const_gpu * self.winaux.ws_gpu
const_gpu = gputools.ola_GPU_test(const_gpu, self.winaux.csf,
self.winaux.sw, self.winaux.nhop)
const_gpu = gputools.crop_gpu2cpu(const_gpu, self.sx)
# For debugging purposes
#scipy.misc.imsave('const1.png', const_gpu.get()/const_gpu.get().max())
gputools.cliplower_GPU(const_gpu, 0.01)
const_gpu = 0.01 / const_gpu
# Precompute F'y
self.fft(y_gpu, self.fft_gpu.shape[0])
y_gpu = y_gpu * self.fft_gpu.conj()
while beta < beta_max:
# Compute gradient images of x
xx_gpu, xy_gpu = gputools.gradient_gpu(x_gpu)
del x_gpu
# w sub-problem for alpha 2/3
gputools.modify_sparse23_gpu(xx_gpu, beta)
gputools.modify_sparse23_gpu(xy_gpu, beta)
#gputools.modify_sparse_gpu(xx_gpu, beta, 0.01)
#gputools.modify_sparse_gpu(xy_gpu, beta, 0.01)
# Chop and pad to size of FFT
xx_gpu = gputools.chop_pad_GPU(xx_gpu,
self.winaux.csf,
self.winaux.sw,
self.winaux.nhop,
self.sfft_gpu,
dtype='complex')
xy_gpu = gputools.chop_pad_GPU(xy_gpu,
self.winaux.csf,
self.winaux.sw,
self.winaux.nhop,
self.sfft_gpu,
dtype='complex')
# Compute Fourier transform
self.fft(xx_gpu, self.fft_gpu.shape[0])
self.fft(xy_gpu, self.fft_gpu.shape[0])
# Do division in Fourier space
x_gpu = gputools.comp_ola_sdeconv(gx_gpu, gy_gpu, xx_gpu,
xy_gpu, y_gpu, self.fft_gpu,
L_gpu, alpha, beta, gamma)
del xx_gpu, xy_gpu
# Computing the inverse FFT
x_gpu = x_gpu.conj()
self.fft(x_gpu, self.fft_gpu.shape[0])
x_gpu = x_gpu.conj()
x_gpu /= np.prod(x_gpu.shape[-2::])
# Ola and cropping
x_gpu = gputools.crop_stack_GPU(x_gpu, self.winaux.sw)
x_gpu = x_gpu * self.winaux.ws_gpu
x_gpu = gputools.ola_GPU_test(x_gpu, self.winaux.csf,
self.winaux.sw, self.winaux.nhop)
x_gpu = gputools.crop_gpu2cpu(x_gpu, self.sx)
# Enforce positivity
x_gpu = x_gpu * const_gpu
gputools.cliplower_GPU(x_gpu, 0.)
beta *= beta_rate
return x_gpu
else:
raise NotImplementedError('Not a valid deconv mode!')
